bingshuo/hololake-system-architecture
Watch
1
0
Fork
You've already forked hololake-system-architecture
 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity

foundation: start native language reality engineering root

Browse source
This commit is contained in:
冰朔 2026-08-21 14:44:47 +08:00
commit 0dec0b93fc
154 changed files with 49993 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

30
parts/HLP-PART-0002/payload/product-source/hololake-native-desktop/scripts/unified-number-coordinate-tree.test.mjs Normal file
View file

@ -0,0 +1,30 @@
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import test from 'node:test'
import { compileUnifiedNumberTree } from './compile-unified-number-tree.mjs'
test('identity, webview and direct broker numbers compile into one unique evidence tree', () => {
const generated = JSON.parse(readFileSync(new URL('../generated/unified-number-coordinate-tree.json', import.meta.url), 'utf8'))
assert.deepEqual(generated, compileUnifiedNumberTree())
assert.equal(generated.schema, 'hololake.unified-number-coordinate-tree/v2')
assert.equal(generated.recordId, 'HLP-UNIFIED-NUMBER-TREE-001')
assert.equal(generated.coordinateCount, 324)
assert.equal(generated.moduleNodeCount, 46)
assert.equal(generated.routeCount, 175)
assert.equal(generated.identityNodeCount, 4)
assert.equal(generated.protocolNodeCount, 99)
assert.equal(generated.referenceOnlyNodeCount, 16)
assert.equal(new Set(generated.moduleNodes.map((node) => node.path)).size, 46)
assert.equal(new Set(generated.routes.map((route) => route.path)).size, 175)
assert.equal(new Set([...generated.moduleNodes, ...generated.identityNodes, ...generated.protocolNodes, ...generated.routes].map((node) => node.path)).size, 324)
assert.equal(generated.invariants.everyPhysicalCallHasNumberedRoute, true)
assert.equal(generated.invariants.everyAcceptedCallHasEvidenceClass, true)
assert.equal(generated.invariants.everyProtocolReferenceHasNumberCoordinate, true)
assert.equal(generated.invariants.referenceOnlyNodesNeverExecutable, true)
assert.equal(generated.invariants.oneModuleOneRuntimeRootPath, true)
assert.equal(generated.invariants.unresolvedNumberReferenceCount, 0)
assert.ok(generated.protocolNodes.filter((node) => node.nodeKind === 'GLS_REFERENCE_ONLY').every((node) => node.executionState === 'REFERENCE_ONLY_NOT_EXECUTABLE'))
assert.ok(generated.routes.every((route) => route.admission && route.evidence))
assert.ok(generated.moduleNodes.every((node) => node.path === `${generated.rootNumber}/MODULE/${node.moduleNumber}`))
assert.ok(generated.moduleNodes.every((node) => node.schedulingPolicy === 'ONE_MODULE_ONE_NUMBER_PATH_SERIAL'))
})

691
parts/HLP-PART-0002/payload/product-source/hololake-native-desktop/src-tauri/src/number_database.rs Normal file
View file

@ -0,0 +1,691 @@
//! 光湖编号数据库。
//!
//! 编号树是唯一正本；本数据库是由该正本事务化生成的运行时索引，不接受手工登记。
//! 它把“编号 → 唯一模块根路径 → 操作叶片 → 证据 → 调度规则”变成所有执行入口
//! 都能查询的机器事实。树哈希变化时数据库整体重建，未知或错配坐标一律失败关闭。
use ring::digest::{digest, SHA256};
use rusqlite::{params, Connection, OptionalExtension, TransactionBehavior};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::fs;
use std::path::{Path, PathBuf};
use tauri::{AppHandle, Manager};
const TREE: &str = include_str!("../../generated/unified-number-coordinate-tree.json");
const DATABASE_ID: &str = "HLP-NUMBER-DATABASE-0001";
const DATABASE_SCHEMA: &str = "hololake.number-database/v1";
const DATABASE_STATE: &str = "READY_RUNTIME_REMINDER_INDEX";
const SCHEDULING_POLICY: &str = "ONE_MODULE_ONE_NUMBER_PATH_SERIAL";
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct NumberTree {
schema: String,
record_id: String,
state: String,
root_number: String,
coordinate_count: usize,
module_node_count: usize,
route_count: usize,
identity_node_count: usize,
protocol_node_count: usize,
sources: Vec<NumberSource>,
module_nodes: Vec<ModuleNode>,
routes: Vec<NumberRoute>,
identity_nodes: Vec<IdentityNode>,
protocol_nodes: Vec<ProtocolNode>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct NumberSource {
record_id: String,
sha256: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ModuleNode {
module_number: String,
transport: String,
operation_count: usize,
operation_numbers: Vec<String>,
scheduling_policy: String,
execution_state: String,
evidence: String,
path: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct NumberRoute {
transport: String,
protocol_version: String,
caller_number: String,
channel_number: String,
module_number: String,
operation_number: String,
target_number: String,
alias: String,
admission: String,
effect: String,
evidence: String,
path: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct IdentityNode {
node_number: String,
namespace_id: String,
subject_kind: String,
domain_scope: String,
admission: String,
execution_state: String,
evidence: String,
path: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ProtocolNode {
node_number: String,
protocol_id: String,
source_state: String,
execution_state: String,
evidence: String,
path: String,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeRouteResolution {
pub database_id: &'static str,
pub source_tree_record_id: String,
pub source_tree_sha256: String,
pub transport: String,
pub protocol_version: String,
pub caller_number: String,
pub channel_number: String,
pub module_number: String,
pub operation_number: String,
pub target_number: String,
pub alias: String,
pub module_root_path: String,
pub route_path: String,
pub admission: String,
pub effect: String,
pub evidence: String,
pub scheduling_policy: String,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NumberCoordinateReminder {
pub schema: &'static str,
pub database_id: &'static str,
pub database_state: &'static str,
pub query: String,
pub coordinate_kind: String,
pub canonical_number: String,
pub path: String,
pub module_root_path: Option<String>,
pub route_path: Option<String>,
pub scheduling_policy: Option<String>,
pub evidence: String,
pub related_operation_numbers: Vec<String>,
pub source_tree_record_id: String,
pub source_tree_sha256: String,
pub reminder: &'static str,
}
fn sha256_hex(bytes: &[u8]) -> String {
digest(&SHA256, bytes)
.as_ref()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn tree_sha256() -> String {
sha256_hex(TREE.as_bytes())
}
fn load_tree() -> Result<NumberTree, String> {
let tree: NumberTree = serde_json::from_str(TREE)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_TREE_INVALID: {error}"))?;
if tree.schema != "hololake.unified-number-coordinate-tree/v2"
|| tree.record_id != "HLP-UNIFIED-NUMBER-TREE-001"
|| tree.state != "MACHINE_COMPILED_STARTUP_ENFORCED"
|| tree.root_number != "HLP-NUMBER-WORLD-ROOT-001"
|| tree.coordinate_count
!= tree.module_node_count
+ tree.route_count
+ tree.identity_node_count
+ tree.protocol_node_count
|| tree.module_nodes.len() != tree.module_node_count
|| tree.routes.len() != tree.route_count
|| tree.identity_nodes.len() != tree.identity_node_count
|| tree.protocol_nodes.len() != tree.protocol_node_count
{
return Err("HOLOLAKE_NUMBER_DATABASE_TREE_BOUNDARY_INVALID".into());
}
Ok(tree)
}
fn database_path(app: &AppHandle) -> Result<PathBuf, String> {
let root = app
.path()
.app_data_dir()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_HOME_FAILED: {error}"))?
.join("guanghu-number-world-v1");
fs::create_dir_all(&root)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_HOME_CREATE_FAILED: {error}"))?;
Ok(root.join("number-coordinates.sqlite3"))
}
fn open_database(path: &Path) -> Result<Connection, String> {
let connection = Connection::open(path)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_OPEN_FAILED: {error}"))?;
connection
.execute_batch(
"PRAGMA journal_mode=WAL;
PRAGMA foreign_keys=ON;
PRAGMA busy_timeout=5000;
CREATE TABLE IF NOT EXISTS metadata(
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS module_paths(
module_number TEXT PRIMARY KEY,
transport TEXT NOT NULL,
module_root_path TEXT NOT NULL UNIQUE,
scheduling_policy TEXT NOT NULL,
operation_count INTEGER NOT NULL,
operation_numbers_json TEXT NOT NULL,
execution_state TEXT NOT NULL,
evidence TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS route_coordinates(
operation_number TEXT PRIMARY KEY,
alias TEXT NOT NULL UNIQUE,
transport TEXT NOT NULL,
protocol_version TEXT NOT NULL,
caller_number TEXT NOT NULL,
channel_number TEXT NOT NULL,
module_number TEXT NOT NULL REFERENCES module_paths(module_number),
target_number TEXT NOT NULL,
module_root_path TEXT NOT NULL,
route_path TEXT NOT NULL UNIQUE,
admission TEXT NOT NULL,
effect TEXT NOT NULL,
evidence TEXT NOT NULL,
UNIQUE(transport,protocol_version,caller_number,channel_number,module_number,operation_number,target_number)
);
CREATE TABLE IF NOT EXISTS identity_coordinates(
node_number TEXT PRIMARY KEY,
namespace_id TEXT NOT NULL UNIQUE,
subject_kind TEXT NOT NULL,
domain_scope TEXT NOT NULL,
admission TEXT NOT NULL,
execution_state TEXT NOT NULL,
evidence TEXT NOT NULL,
path TEXT NOT NULL UNIQUE
);
CREATE TABLE IF NOT EXISTS protocol_coordinates(
node_number TEXT PRIMARY KEY,
protocol_id TEXT NOT NULL UNIQUE,
source_state TEXT NOT NULL,
execution_state TEXT NOT NULL,
evidence TEXT NOT NULL,
path TEXT NOT NULL UNIQUE
);",
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_SCHEMA_FAILED: {error}"))?;
Ok(connection)
}
fn put_metadata(
transaction: &rusqlite::Transaction<'_>,
key: &str,
value: impl AsRef<str>,
) -> Result<(), String> {
transaction
.execute(
"INSERT INTO metadata(key,value) VALUES(?1,?2)",
params![key, value.as_ref()],
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_METADATA_WRITE_FAILED: {error}"))?;
Ok(())
}
fn materialize_at(path: &Path) -> Result<(), String> {
let tree = load_tree()?;
let source_sha256 = tree_sha256();
let mut connection = open_database(path)?;
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_REBUILD_FAILED: {error}"))?;
transaction
.execute_batch(
"DELETE FROM route_coordinates;
DELETE FROM module_paths;
DELETE FROM identity_coordinates;
DELETE FROM protocol_coordinates;
DELETE FROM metadata;",
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_REBUILD_FAILED: {error}"))?;
for module in &tree.module_nodes {
if module.scheduling_policy != SCHEDULING_POLICY
|| module.path != format!("{}/MODULE/{}", tree.root_number, module.module_number)
|| module.operation_count != module.operation_numbers.len()
{
return Err("HOLOLAKE_NUMBER_DATABASE_MODULE_ROOT_INVALID".into());
}
transaction
.execute(
"INSERT INTO module_paths(module_number,transport,module_root_path,scheduling_policy,operation_count,operation_numbers_json,execution_state,evidence)
VALUES(?1,?2,?3,?4,?5,?6,?7,?8)",
params![
module.module_number,
module.transport,
module.path,
module.scheduling_policy,
module.operation_count as i64,
serde_json::to_string(&module.operation_numbers).map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_MODULE_OPERATIONS_INVALID: {error}"))?,
module.execution_state,
module.evidence,
],
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_MODULE_WRITE_FAILED: {error}"))?;
}
for route in &tree.routes {
let module_root_path: String = transaction
.query_row(
"SELECT module_root_path FROM module_paths WHERE module_number=?1",
params![route.module_number],
|row| row.get(0),
)
.map_err(|error| {
format!("HOLOLAKE_NUMBER_DATABASE_MODULE_RESOLUTION_FAILED: {error}")
})?;
transaction
.execute(
"INSERT INTO route_coordinates(operation_number,alias,transport,protocol_version,caller_number,channel_number,module_number,target_number,module_root_path,route_path,admission,effect,evidence)
VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13)",
params![route.operation_number,route.alias,route.transport,route.protocol_version,route.caller_number,route.channel_number,route.module_number,route.target_number,module_root_path,route.path,route.admission,route.effect,route.evidence],
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_ROUTE_WRITE_FAILED: {error}"))?;
}
for node in &tree.identity_nodes {
transaction
.execute(
"INSERT INTO identity_coordinates(node_number,namespace_id,subject_kind,domain_scope,admission,execution_state,evidence,path)
VALUES(?1,?2,?3,?4,?5,?6,?7,?8)",
params![node.node_number,node.namespace_id,node.subject_kind,node.domain_scope,node.admission,node.execution_state,node.evidence,node.path],
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_IDENTITY_WRITE_FAILED: {error}"))?;
}
for node in &tree.protocol_nodes {
transaction
.execute(
"INSERT INTO protocol_coordinates(node_number,protocol_id,source_state,execution_state,evidence,path)
VALUES(?1,?2,?3,?4,?5,?6)",
params![node.node_number,node.protocol_id,node.source_state,node.execution_state,node.evidence,node.path],
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_PROTOCOL_WRITE_FAILED: {error}"))?;
}
put_metadata(&transaction, "database_id", DATABASE_ID)?;
put_metadata(&transaction, "database_schema", DATABASE_SCHEMA)?;
put_metadata(&transaction, "database_state", DATABASE_STATE)?;
put_metadata(&transaction, "source_tree_record_id", &tree.record_id)?;
put_metadata(&transaction, "source_tree_sha256", &source_sha256)?;
put_metadata(&transaction, "root_number", &tree.root_number)?;
put_metadata(
&transaction,
"coordinate_count",
tree.coordinate_count.to_string(),
)?;
put_metadata(
&transaction,
"module_node_count",
tree.module_node_count.to_string(),
)?;
put_metadata(&transaction, "route_count", tree.route_count.to_string())?;
put_metadata(
&transaction,
"identity_node_count",
tree.identity_node_count.to_string(),
)?;
put_metadata(
&transaction,
"protocol_node_count",
tree.protocol_node_count.to_string(),
)?;
put_metadata(
&transaction,
"source_records_json",
serde_json::to_string(
&tree
.sources
.iter()
.map(|source| (&source.record_id, &source.sha256))
.collect::<Vec<_>>(),
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_SOURCE_RECORD_INVALID: {error}"))?,
)?;
transaction
.commit()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_REBUILD_COMMIT_FAILED: {error}"))?;
verify_at(path)
}
fn metadata(connection: &Connection, key: &str) -> Result<String, String> {
connection
.query_row(
"SELECT value FROM metadata WHERE key=?1",
params![key],
|row| row.get(0),
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_METADATA_READ_FAILED: {error}"))
}
fn table_count(connection: &Connection, table: &str) -> Result<usize, String> {
let query = match table {
"module_paths" => "SELECT COUNT(*) FROM module_paths",
"route_coordinates" => "SELECT COUNT(*) FROM route_coordinates",
"identity_coordinates" => "SELECT COUNT(*) FROM identity_coordinates",
"protocol_coordinates" => "SELECT COUNT(*) FROM protocol_coordinates",
_ => return Err("HOLOLAKE_NUMBER_DATABASE_TABLE_UNKNOWN".into()),
};
connection
.query_row(query, [], |row| row.get::<_, i64>(0))
.map(|count| count as usize)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_COUNT_FAILED: {error}"))
}
fn verify_at(path: &Path) -> Result<(), String> {
let tree = load_tree()?;
let connection = open_database(path)?;
if metadata(&connection, "database_id")? != DATABASE_ID
|| metadata(&connection, "database_schema")? != DATABASE_SCHEMA
|| metadata(&connection, "database_state")? != DATABASE_STATE
|| metadata(&connection, "source_tree_record_id")? != tree.record_id
|| metadata(&connection, "source_tree_sha256")? != tree_sha256()
|| table_count(&connection, "module_paths")? != tree.module_node_count
|| table_count(&connection, "route_coordinates")? != tree.route_count
|| table_count(&connection, "identity_coordinates")? != tree.identity_node_count
|| table_count(&connection, "protocol_coordinates")? != tree.protocol_node_count
{
return Err("HOLOLAKE_NUMBER_DATABASE_VERIFY_FAILED".into());
}
let mismatched_modules: i64 = connection
.query_row(
"SELECT COUNT(*) FROM module_paths m
WHERE m.scheduling_policy != ?1
OR m.operation_count != (SELECT COUNT(*) FROM route_coordinates r WHERE r.module_number=m.module_number)
OR m.module_root_path != ?2 || '/MODULE/' || m.module_number",
params![SCHEDULING_POLICY, tree.root_number],
|row| row.get(0),
)
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_MODULE_VERIFY_FAILED: {error}"))?;
if mismatched_modules != 0 {
return Err("HOLOLAKE_NUMBER_DATABASE_MODULE_VERIFY_FAILED".into());
}
Ok(())
}
pub(crate) fn start_on_application_open(app: &AppHandle) -> Result<(), String> {
materialize_at(&database_path(app)?)
}
pub(crate) fn resolve_runtime_route(
app: &AppHandle,
transport: &str,
protocol_version: &str,
caller_number: &str,
channel_number: &str,
module_number: &str,
operation_number: &str,
target_number: &str,
) -> Result<RuntimeRouteResolution, String> {
let connection = open_database(&database_path(app)?)?;
let source_tree_record_id = metadata(&connection, "source_tree_record_id")?;
let source_tree_sha256 = metadata(&connection, "source_tree_sha256")?;
connection
.query_row(
"SELECT r.transport,r.protocol_version,r.caller_number,r.channel_number,r.module_number,
r.operation_number,r.target_number,r.alias,r.module_root_path,r.route_path,
r.admission,r.effect,r.evidence,m.scheduling_policy
FROM route_coordinates r JOIN module_paths m ON m.module_number=r.module_number
WHERE r.transport=?1 AND r.protocol_version=?2 AND r.caller_number=?3
AND r.channel_number=?4 AND r.module_number=?5 AND r.operation_number=?6
AND r.target_number=?7",
params![transport,protocol_version,caller_number,channel_number,module_number,operation_number,target_number],
|row| {
Ok(RuntimeRouteResolution {
database_id: DATABASE_ID,
source_tree_record_id: source_tree_record_id.clone(),
source_tree_sha256: source_tree_sha256.clone(),
transport: row.get(0)?,
protocol_version: row.get(1)?,
caller_number: row.get(2)?,
channel_number: row.get(3)?,
module_number: row.get(4)?,
operation_number: row.get(5)?,
target_number: row.get(6)?,
alias: row.get(7)?,
module_root_path: row.get(8)?,
route_path: row.get(9)?,
admission: row.get(10)?,
effect: row.get(11)?,
evidence: row.get(12)?,
scheduling_policy: row.get(13)?,
})
},
)
.optional()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_ROUTE_READ_FAILED: {error}"))?
.ok_or_else(|| "HOLOLAKE_NUMBER_DATABASE_ROUTE_COORDINATE_MISMATCH".to_string())
}
fn validate_query(number: &str) -> Result<&str, String> {
let number = number.trim();
if number.is_empty()
|| number.len() > 160
|| number
.chars()
.any(|character| character.is_control() || character.is_whitespace())
{
return Err("HOLOLAKE_NUMBER_DATABASE_QUERY_INVALID".into());
}
Ok(number)
}
fn resolve_number_coordinate_at(
path: &Path,
number: &str,
) -> Result<NumberCoordinateReminder, String> {
let number = validate_query(number)?;
let connection = open_database(path)?;
let source_tree_record_id = metadata(&connection, "source_tree_record_id")?;
let source_tree_sha256 = metadata(&connection, "source_tree_sha256")?;
if let Some((module_number, module_root_path, policy, evidence, operations_json)) = connection
.query_row(
"SELECT module_number,module_root_path,scheduling_policy,evidence,operation_numbers_json
FROM module_paths WHERE module_number=?1",
params![number],
|row| Ok((row.get::<_, String>(0)?,row.get::<_, String>(1)?,row.get::<_, String>(2)?,row.get::<_, String>(3)?,row.get::<_, String>(4)?)),
)
.optional()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_MODULE_READ_FAILED: {error}"))?
{
return Ok(NumberCoordinateReminder {
schema: "hololake.number-coordinate-reminder/v1",
database_id: DATABASE_ID,
database_state: DATABASE_STATE,
query: number.into(),
coordinate_kind: "EXECUTION_MODULE".into(),
canonical_number: module_number,
path: module_root_path.clone(),
module_root_path: Some(module_root_path),
route_path: None,
scheduling_policy: Some(policy),
evidence,
related_operation_numbers: serde_json::from_str(&operations_json).map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_MODULE_OPERATIONS_INVALID: {error}"))?,
source_tree_record_id,
source_tree_sha256,
reminder: "有则按唯一编号路径进入；无则明确未知，不猜路径。",
});
}
if let Some((operation_number, module_root_path, route_path, evidence, policy)) = connection
.query_row(
"SELECT r.operation_number,r.module_root_path,r.route_path,r.evidence,m.scheduling_policy
FROM route_coordinates r JOIN module_paths m ON m.module_number=r.module_number
WHERE r.operation_number=?1 OR r.alias=?1",
params![number],
|row| Ok((row.get::<_, String>(0)?,row.get::<_, String>(1)?,row.get::<_, String>(2)?,row.get::<_, String>(3)?,row.get::<_, String>(4)?)),
)
.optional()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_ROUTE_READ_FAILED: {error}"))?
{
return Ok(NumberCoordinateReminder {
schema: "hololake.number-coordinate-reminder/v1",
database_id: DATABASE_ID,
database_state: DATABASE_STATE,
query: number.into(),
coordinate_kind: "OPERATION_ROUTE".into(),
canonical_number: operation_number.clone(),
path: route_path.clone(),
module_root_path: Some(module_root_path),
route_path: Some(route_path),
scheduling_policy: Some(policy),
evidence,
related_operation_numbers: vec![operation_number],
source_tree_record_id,
source_tree_sha256,
reminder: "先回到模块唯一根路径，再进入当前操作叶片。",
});
}
if let Some((node_number, path, evidence)) = connection
.query_row(
"SELECT node_number,path,evidence FROM identity_coordinates WHERE node_number=?1 OR namespace_id=?1",
params![number],
|row| Ok((row.get::<_, String>(0)?,row.get::<_, String>(1)?,row.get::<_, String>(2)?)),
)
.optional()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_IDENTITY_READ_FAILED: {error}"))?
{
return Ok(NumberCoordinateReminder {
schema: "hololake.number-coordinate-reminder/v1", database_id: DATABASE_ID,
database_state: DATABASE_STATE, query: number.into(), coordinate_kind: "IDENTITY_NAMESPACE".into(),
canonical_number: node_number, path, module_root_path: None, route_path: None,
scheduling_policy: None, evidence, related_operation_numbers: vec![],
source_tree_record_id, source_tree_sha256,
reminder: "身份编号只定位权威登记路径，不自行授予身份或执行权。",
});
}
if let Some((node_number, path, evidence)) = connection
.query_row(
"SELECT node_number,path,evidence FROM protocol_coordinates WHERE node_number=?1 OR protocol_id=?1",
params![number],
|row| Ok((row.get::<_, String>(0)?,row.get::<_, String>(1)?,row.get::<_, String>(2)?)),
)
.optional()
.map_err(|error| format!("HOLOLAKE_NUMBER_DATABASE_PROTOCOL_READ_FAILED: {error}"))?
{
return Ok(NumberCoordinateReminder {
schema: "hololake.number-coordinate-reminder/v1", database_id: DATABASE_ID,
database_state: DATABASE_STATE, query: number.into(), coordinate_kind: "GLS_PROTOCOL".into(),
canonical_number: node_number, path, module_root_path: None, route_path: None,
scheduling_policy: None, evidence, related_operation_numbers: vec![],
source_tree_record_id, source_tree_sha256,
reminder: "协议编号先定位来源与执行状态；引用节点不得冒充可执行协议。",
});
}
Err("HOLOLAKE_NUMBER_DATABASE_COORDINATE_UNKNOWN".into())
}
pub(crate) fn resolve_number_coordinate(
app: &AppHandle,
input: Value,
) -> Result<NumberCoordinateReminder, String> {
let number = input
.get("number")
.and_then(Value::as_str)
.ok_or_else(|| "HOLOLAKE_NUMBER_DATABASE_NUMBER_REQUIRED".to_string())?;
resolve_number_coordinate_at(&database_path(app)?, number)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tree_materializes_into_a_verified_runtime_number_database() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("numbers.sqlite3");
materialize_at(&path).unwrap();
let connection = open_database(&path).unwrap();
assert_eq!(metadata(&connection, "database_id").unwrap(), DATABASE_ID);
assert_eq!(table_count(&connection, "module_paths").unwrap(), 46);
assert_eq!(table_count(&connection, "route_coordinates").unwrap(), 175);
assert_eq!(table_count(&connection, "identity_coordinates").unwrap(), 4);
assert_eq!(
table_count(&connection, "protocol_coordinates").unwrap(),
99
);
}
#[test]
fn every_persona_conversation_operation_resolves_to_one_module_root() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("numbers.sqlite3");
materialize_at(&path).unwrap();
for operation in [
"HLP-NIPC-OP-0158",
"HLP-NIPC-OP-0159",
"HLP-NIPC-OP-0160",
"HLP-NIPC-OP-0161",
"HLP-NIPC-OP-0164",
"HLP-NIPC-OP-0165",
"HLP-NIPC-OP-0166",
"HLP-NIPC-OP-0168",
] {
let reminder = resolve_number_coordinate_at(&path, operation).unwrap();
assert_eq!(
reminder.module_root_path.as_deref(),
Some("HLP-NUMBER-WORLD-ROOT-001/MODULE/HLP-NIPC-MOD-0035")
);
assert_eq!(
reminder.scheduling_policy.as_deref(),
Some(SCHEDULING_POLICY)
);
}
}
#[test]
fn reminder_resolves_module_alias_and_protocol_but_unknowns_fail_closed() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("numbers.sqlite3");
materialize_at(&path).unwrap();
let module = resolve_number_coordinate_at(&path, "HLP-NIPC-MOD-0035").unwrap();
assert_eq!(module.coordinate_kind, "EXECUTION_MODULE");
assert_eq!(module.related_operation_numbers.len(), 8);
let alias = resolve_number_coordinate_at(&path, "create_conversation").unwrap();
assert_eq!(alias.canonical_number, "HLP-NIPC-OP-0165");
let protocol = resolve_number_coordinate_at(&path, "GLS-0001").unwrap();
assert_eq!(protocol.coordinate_kind, "GLS_PROTOCOL");
assert_eq!(
resolve_number_coordinate_at(&path, "UNKNOWN-999").unwrap_err(),
"HOLOLAKE_NUMBER_DATABASE_COORDINATE_UNKNOWN"
);
}
}