@wowok/agent-mcp 2.7.1 → 2.7.3

package/dist/knowledge/guard-translation.js

@@ -1,1119 +1 @@
-import { MAX_SUBMISSION_SIZE_PASSPORT } from "@wowok/wowok";
-export const SEMANTIC_TO_SCHEMA_RULES = [
-    {
-        id: "P02",
-        pattern_name: "Query published object + system context",
-        data_source_combination: "Type1 + Type4",
-        semantic_intent: "Query published on-chain object fields and compare with system context",
-        match_keywords: ["paused", "published", "service status", "machine status", "paused", "published"],
-        schema_elements: {
-            root_type: "logic_equal / logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "Published object address constant (Type1)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Optional: identity validation" },
-            ],
-            tree_structure: "logic_equal(query(<instruction>, object: { identifier: 0 }), identifier[1] or context(Signer))",
-        },
-        constraints: [
-            "The object_type of table[0] must match the target object type of the query instruction",
-            "The query return type must be compatible with the comparison object",
-            "The object must be published (published=true) to ensure fields are immutable",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    { type: "query", query: "service.paused", object: { identifier: 0 }, parameters: [] },
-                    { type: "identifier", identifier: 1 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xSERVICE", name: "Service object address" },
-                { identifier: 1, b_submission: false, value_type: "Bool", value: false, name: "Expected paused state (false=not paused)" },
-            ],
-        },
-    },
-    {
-        id: "P03",
-        pattern_name: "Identity check (single address)",
-        data_source_combination: "Type4 + Type1 constant",
-        semantic_intent: "Only a specific address can perform the operation",
-        match_keywords: ["only", "allow", "authorize", "identity", "specified address", "signer"],
-        schema_elements: {
-            root_type: "logic_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "Authorized address constant (Type1 constant)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Current transaction signer (Type4)" },
-            ],
-            tree_structure: "logic_equal(context(Signer), identifier[0])",
-        },
-        constraints: [
-            "root must be logic_equal (returns Bool)",
-            "table[0] must be Address type, b_submission=false",
-            "context(Signer) returns the current transaction signer address",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    { type: "context", context: "Signer" },
-                    { type: "identifier", identifier: 0 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xabc...", name: "Authorized operator address" },
-            ],
-        },
-    },
-    {
-        id: "P04",
-        pattern_name: "Identity check (whitelist)",
-        data_source_combination: "Type4 + Type1 constant (VecAddress)",
-        semantic_intent: "Addresses in the whitelist can perform this operation",
-        match_keywords: ["whitelist", "multiple addresses", "list", "allowlist", "roster"],
-        schema_elements: {
-            root_type: "vec_contains_address",
-            table_entries: [
-                { value_type: "VecAddress", b_submission: false, purpose: "Authorized address list (Type1 constant)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Signer being looked up (Type4)" },
-            ],
-            tree_structure: "vec_contains_address(identifier[0], context(Signer))",
-        },
-        constraints: [
-            "root vec_contains_address returns Bool",
-            "table[0] must be VecAddress type",
-            "context(Signer) is the element being looked up",
-        ],
-        example: {
-            root: {
-                type: "vec_contains_address",
-                nodes: [
-                    { type: "identifier", identifier: 0 },
-                    { type: "context", context: "Signer" },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "VecAddress", value: ["0xabc...", "0xdef..."], name: "Authorized address whitelist" },
-            ],
-        },
-    },
-    {
-        id: "P05",
-        pattern_name: "Time lock",
-        data_source_combination: "Type2 + Type4 + Type1 constant",
-        semantic_intent: "This operation can only be executed after waiting N milliseconds",
-        match_keywords: ["wait", "time", "lock", "delay", "hours", "days", "milliseconds"],
-        schema_elements: {
-            root_type: "logic_as_u256_greater_or_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Source object address (e.g. Order, Type3) or constant (Type1)" },
-                { value_type: "U64", b_submission: false, purpose: "Lock duration (in milliseconds, 1000 for tests, Type1 constant)" },
-            ],
-            query_nodes: [
-                { query_name: "progress.current_time", object_type: "Progress", convert_witness: 100 },
-            ],
-            context_nodes: [
-                { context_type: "Clock", purpose: "Current on-chain timestamp (Type4)" },
-            ],
-            tree_structure: "logic_as_u256_greater_or_equal(context(Clock), calc_number_add(query(1272: progress.current_time, witness=100, identifier[0]), identifier[1]))",
-        },
-        constraints: [
-            "Time unit is milliseconds; use 1000ms for tests and adjust in production",
-            "convert_witness=100 (TypeOrderProgress) converts from Order to Progress",
-            "The object_type of table[0] must match the witness source type (Order)",
-            "calc_number_add returns U256, context(Clock) returns U64, auto-widened",
-            "Key: use progress.current_time(1272) rather than progress.session.forward.time(1271); the latter querying an unforwarded session returns 0 and disables the time lock",
-        ],
-        example: {
-            root: {
-                type: "logic_as_u256_greater_or_equal",
-                nodes: [
-                    { type: "context", context: "Clock" },
-                    {
-                        type: "calc_number_add",
-                        nodes: [
-                            {
-                                type: "query",
-                                query: "progress.current_time",
-                                object: { identifier: 0, convert_witness: 100 },
-                                parameters: [],
-                            },
-                            { type: "identifier", identifier: 1 },
-                        ],
-                    },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Target Order address", object_type: "Order" },
-                { identifier: 1, b_submission: false, value_type: "U64", value: 1000, name: "Lock duration (milliseconds)" },
-            ],
-        },
-    },
-    {
-        id: "P06",
-        pattern_name: "Progress state check",
-        data_source_combination: "Type2 + Type1 constant",
-        semantic_intent: "The order progress must reach the specified node before this operation can be executed",
-        match_keywords: ["progress", "node", "state", "completed", "reach", "current node"],
-        schema_elements: {
-            root_type: "logic_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Source Order address (Type3, witness source)" },
-                { value_type: "String", b_submission: false, purpose: "Expected node name (Type1 constant)" },
-            ],
-            query_nodes: [
-                { query_name: "progress.current", object_type: "Progress", convert_witness: 100 },
-            ],
-            tree_structure: "logic_equal(query(1253: progress.current, witness=100, identifier[0]), identifier[1])",
-        },
-        constraints: [
-            "query returns String; identifier[1] must be String type",
-            "logic_equal comparison on String is case-sensitive",
-            "For case-insensitive comparison, use logic_string_nocase_equal",
-            "convert_witness=100 (TypeOrderProgress) converts from Order",
-            "Type2 stacks on Type3: the source object Order is submitted (b_submission=true)",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    {
-                        type: "query",
-                        query: "progress.current",
-                        object: { identifier: 0, convert_witness: 100 },
-                        parameters: [],
-                    },
-                    { type: "identifier", identifier: 1 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Target Order address", object_type: "Order" },
-                { identifier: 1, b_submission: false, value_type: "String", value: "Completed", name: "Expected progress node name" },
-            ],
-        },
-    },
-    {
-        id: "P07",
-        pattern_name: "One-time claim check",
-        data_source_combination: "Type3 + Type1 constant",
-        semantic_intent: "Users can only claim the reward once",
-        match_keywords: ["once", "claim", "duplicate", "already claimed", "claimed before"],
-        schema_elements: {
-            root_type: "logic_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Reward object address (Type3, submitted)" },
-                { value_type: "U64", b_submission: false, purpose: "Expected historical claim count 0 (Type1 constant)" },
-            ],
-            query_nodes: [
-                { query_name: "reward.record.count", object_type: "Reward" },
-            ],
-            tree_structure: "logic_equal(query_reward_record_count(object: { identifier: 0 }, recipient: context(Signer)), identifier[1])",
-        },
-        constraints: [
-            "query_reward_record_count returns U64",
-            "Comparing count == 0 means no history record (can claim)",
-            "recipient defaults to context(Signer) to ensure the claimer's identity is bound",
-            "Type3 submitted objects must have constraint rules (here the constraint is count==0 and recipient=Signer)",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    {
-                        type: "query_reward_record_count",
-                        object: { identifier: 0 },
-                    },
-                    { type: "identifier", identifier: 1 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Reward object address", object_type: "Reward" },
-                { identifier: 1, b_submission: false, value_type: "U64", value: 0, name: "Expected historical claim count (0)" },
-            ],
-        },
-    },
-    {
-        id: "P08",
-        pattern_name: "Submitted object identity validation",
-        data_source_combination: "Type3 + Type4",
-        semantic_intent: "Verify that the owner of the submitted object matches the signer",
-        match_keywords: ["ownership", "belonging", "customer", "submitted object", "order.customer"],
-        schema_elements: {
-            root_type: "logic_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Submitted Order address (Type3)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Current signer (Type4), compared with order.customer" },
-            ],
-            query_nodes: [
-                { query_name: "order.customer", object_type: "Order" },
-            ],
-            tree_structure: "logic_equal(query(1550: order.customer, object: { identifier: 0 }), context(Signer))",
-        },
-        constraints: [
-            "query returns Address, context(Signer) returns Address, types compatible",
-            "Type3 submitted object constraint: indirectly binds submitter identity via order.customer == Signer",
-            "Ensures callers cannot submit other users' Order addresses",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    {
-                        type: "query",
-                        query: "order.customer",
-                        object: { identifier: 0 },
-                        parameters: [],
-                    },
-                    { type: "context", context: "Signer" },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "User-submitted Order address", object_type: "Order" },
-            ],
-        },
-    },
-    {
-        id: "P09",
-        pattern_name: "Submitted object + witness derivation query",
-        data_source_combination: "Type3 + Type2 (source is Type3)",
-        semantic_intent: "User submits an Order and queries the Progress state via witness",
-        match_keywords: ["submit", "derive", "witness", "order to progress", "convert"],
-        schema_elements: {
-            root_type: "logic_equal / logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Submitted Order address (Type3, witness source)" },
-                { value_type: "String", b_submission: false, purpose: "Expected node name (Type1 constant)" },
-            ],
-            query_nodes: [
-                { query_name: "progress.current", object_type: "Progress", convert_witness: 100 },
-            ],
-            tree_structure: "logic_equal(query(1253: progress.current, object: { identifier: 0, convert_witness: 100 }), identifier[1])",
-        },
-        constraints: [
-            "Type2 stacks on Type3: the source object Order has b_submission=true",
-            "witness=100 (TypeOrderProgress) derives Progress from the submitted Order",
-            "query returns String; identifier[1] must be String type",
-            "Key: Type2 can stack on Type1 or Type3, depending on the source object's b_submission",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    {
-                        type: "query",
-                        query: "progress.current",
-                        object: { identifier: 0, convert_witness: 100 },
-                        parameters: [],
-                    },
-                    { type: "identifier", identifier: 1 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "User-submitted Order address", object_type: "Order" },
-                { identifier: 1, b_submission: false, value_type: "String", value: "Inspecting", name: "Expected progress node name" },
-            ],
-        },
-    },
-    {
-        id: "P10",
-        pattern_name: "Multi-condition combination (AND/OR)",
-        data_source_combination: "Type1 + Type2 + Type3 + Type4 (combination)",
-        semantic_intent: "Multiple conditions must all be satisfied (AND) or any one is satisfied (OR)",
-        match_keywords: ["and", "simultaneously", "all satisfied", "AND", "and also", "also need", "or", "any", "OR", "or", "one of"],
-        schema_elements: {
-            root_type: "logic_and / logic_or",
-            table_entries: [],
-            tree_structure: "logic_and/logic_or([condition1, condition2, ...]) — each condition can be any combination of P03-P09",
-        },
-        constraints: [
-            "All subnodes of logic_and/logic_or must return Bool",
-            "Subnode count 2-8 (MAX_MULTI_OPERANDS)",
-            "Each subcondition can be any node that returns Bool",
-            "Multi-condition combination is a container for other Patterns and does not stand alone",
-        ],
-        example: {
-            root: {
-                type: "logic_and",
-                nodes: [
-                    {},
-                    {},
-                ],
-            },
-        },
-    },
-    {
-        id: "P11",
-        pattern_name: "Entity registration check",
-        data_source_combination: "Type1 system address + Type3",
-        semantic_intent: "Verify that the user is registered in the entity registrar",
-        match_keywords: ["register", "entity", "EntityRegistrar", "member", "certify"],
-        schema_elements: {
-            root_type: "logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "EntityRegistrar system address 0xaab (Type1 system address)" },
-                { value_type: "Address", b_submission: true, purpose: "User address (Type3, submitted)" },
-            ],
-            query_nodes: [
-                { query_name: "entity.registrar.records", object_type: "EntityRegistrar" },
-            ],
-            tree_structure: "logic_and(query(1760: entity.registrar.records, object: { identifier: 0 }, parameters: [identifier[1]]), ...)",
-        },
-        constraints: [
-            "EntityRegistrar address is fixed at 0xaab (system address)",
-            "EntityLinker address is fixed at 0xaaa",
-            "table[0] has is_system_address=true",
-            "query parameters must match the instruction definition",
-        ],
-        example: {
-            root: {
-                type: "logic_and",
-                nodes: [
-                    {
-                        type: "query",
-                        query: "entity.registrar.records",
-                        object: { identifier: 0 },
-                        parameters: [{ type: "identifier", identifier: 1 }],
-                    },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xaab", name: "EntityRegistrar system address" },
-                { identifier: 1, b_submission: true, value_type: "Address", name: "User address (submitted)" },
-            ],
-        },
-    },
-    {
-        id: "P12",
-        pattern_name: "Dynamic voting weight",
-        data_source_combination: "Type3 + Type4 + Type1 constant",
-        semantic_intent: "Voting weight equals the reputation score (extracted from submitted data)",
-        match_keywords: ["weight", "vote", "reputation", "score", "voting", "weight"],
-        schema_elements: {
-            root_type: "logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Voter address (Type3)" },
-                { value_type: "U64", b_submission: true, purpose: "Voter weight (Type3, extracted by GuardIdentifier)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Validate voter identity (Type4)" },
-            ],
-            query_nodes: [
-                { query_name: "entity.registrar.records", object_type: "EntityRegistrar" },
-            ],
-            tree_structure: "logic_and(identity check: logic_equal(context(Signer), identifier[0]), weight comparison: GuardIdentifier extracts identifier[1])",
-        },
-        constraints: [
-            "The table entry referenced by GuardIdentifier must be numeric (U8-U256)",
-            "b_submission must be true (weight is submitted at runtime by the voter)",
-            "Non-numeric types cause E_GUARD_IDENTIFIER_NOT_NUMBER error",
-            "Weight value is cast to u32",
-            "voting_guard scene special constraint: GuardIdentifier numeric",
-        ],
-        example: {
-            root: {
-                type: "logic_and",
-                nodes: [
-                    {},
-                    {},
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Voter address" },
-                { identifier: 1, b_submission: true, value_type: "U64", name: "Voter weight (extracted from reputation score)" },
-            ],
-        },
-    },
-    {
-        id: "P13",
-        pattern_name: "Repository data query",
-        data_source_combination: "Type1 + Type2",
-        semantic_intent: "Query Repository data and validate",
-        match_keywords: ["Repository", "storage", "data source", "weather", "external data", "oracle"],
-        schema_elements: {
-            root_type: "logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "Repository address (Type1 constant)" },
-            ],
-            query_nodes: [
-                { query_name: "repository.data", object_type: "Repository" },
-            ],
-            tree_structure: "logic_and(query(1167: repository.data, object: { identifier: 0 }, parameters: [...]), [data validation condition])",
-        },
-        constraints: [
-            "quote_guard is a RIGID verification requirement: any guard querying Repository data with quote_guard must satisfy it",
-            "Two-phase: passport generation scans/prepares quote_guard, passport verification re-checks + verifies (see R-X1-10)",
-            "If quote_guard==None: no access control — Repository data is freely queryable",
-            "rep semantics: repository.data query does not depend on runtime submission, so rep=true",
-        ],
-        example: {
-            root: {
-                type: "logic_and",
-                nodes: [
-                    {
-                        type: "query",
-                        query: "repository.data",
-                        object: { identifier: 0 },
-                        parameters: [{ type: "identifier", identifier: 1 }],
-                    },
-                    {},
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xREPO", name: "Repository address" },
-            ],
-        },
-    },
-    {
-        id: "P14",
-        pattern_name: "Pure dependency combination",
-        data_source_combination: "None (rely only)",
-        semantic_intent: "Does not compute itself; fully depends on the results of other Guards",
-        match_keywords: ["depend", "combine", "reuse", "rely", "delegate"],
-        schema_elements: {
-            root_type: "logic_and / logic_or (minimized tautology)",
-            table_entries: [],
-            tree_structure: "root: minimized (e.g. context(Clock) >= 0, tautology) + rely: { guards: [...], logic_or: false }",
-        },
-        constraints: [
-            "Depended-on Guards must have rep=true (repository.data query does not depend on runtime submission)",
-            "rely.guards supports at most 4 (MAX_DEPENDED_COUNT)",
-            "Self-reference is forbidden",
-            "AND logic: all dependencies must pass; OR logic: any one passing is sufficient",
-        ],
-        example: {
-            root: {
-                type: "logic_as_u256_greater_or_equal",
-                nodes: [
-                    { type: "context", context: "Clock" },
-                    { type: "identifier", identifier: 0 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "U64", value: 0, name: "Tautology baseline value (0)" },
-            ],
-            rely: { guards: ["guard_a", "guard_b"], logic_or: false },
-        },
-    },
-    {
-        id: "P15",
-        pattern_name: "Submission data retention pattern (retained_submission)",
-        data_source_combination: "Type3 + Type4 (submission + system context binding)",
-        semantic_intent: "Guard accepts runtime-submitted data but ensures it is trustworthy via Signer binding and type checking",
-        match_keywords: ["submit", "retain", "retained", "submission", "bind signer", "submission check"],
-        schema_elements: {
-            root_type: "logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: true, purpose: "Submitted object address (Type3, requires Signer binding)" },
-                { value_type: "U256", b_submission: true, purpose: "Submitted numeric value (e.g. amount, weight, requires range check)" },
-            ],
-            context_nodes: [
-                { context_type: "Signer", purpose: "Validate submitter identity to ensure submission data ownership" },
-            ],
-            tree_structure: "logic_and(logic_equal(context(Signer), query(..., signer_field)), logic_as_u256_greater_or_equal(identifier[1], identifier[2]))",
-        },
-        constraints: [
-            "The name of each b_submission=true entry must be a complete natural-language description (not a technical identifier)",
-            "The submitted object address should be bound to Signer (query the signer/owner field of the submitted object to validate ownership)",
-            "Submitted numeric values should have range checks (>= min, <= max)",
-            "Total table size must not exceed 40000 bytes",
-            `Total submission bytes must not exceed ${MAX_SUBMISSION_SIZE_PASSPORT}`,
-        ],
-        example: {
-            root: {
-                type: "logic_and",
-                nodes: [
-                    {
-                        type: "logic_equal",
-                        nodes: [
-                            { type: "context", context: "Signer" },
-                            {
-                                type: "query",
-                                query: 1237,
-                                object: { identifier: 0 },
-                                parameters: [],
-                            },
-                        ],
-                    },
-                    {
-                        type: "logic_as_u256_greater_or_equal",
-                        nodes: [
-                            { type: "identifier", identifier: 1 },
-                            { type: "identifier", identifier: 2 },
-                        ],
-                    },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: true, value_type: "Address", name: "Submitted Order object address; must belong to the current signer" },
-                { identifier: 1, b_submission: true, value_type: "U256", name: "Submitted amount (unit: MIST); must be >= minimum amount" },
-                { identifier: 2, b_submission: false, value_type: "U256", value: 1000000, name: "Minimum amount constant (1 MIST)" },
-            ],
-        },
-    },
-    {
-        id: "P16",
-        pattern_name: "Circular reference pattern (Guard references the host object itself)",
-        data_source_combination: "Type1 (host object as constant, using name instead of address)",
-        semantic_intent: "Guard binds to a Host Object while querying the Host Object's own fields; uses name reference to achieve circular binding",
-        match_keywords: ["circular reference", "self", "host", "host", "circular", "self-reference"],
-        schema_elements: {
-            root_type: "logic_equal / logic_and",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "Host object name (SDK resolves to address at binding time)" },
-            ],
-            query_nodes: [
-                { query_name: "query_service_* / query_machine_*", object_type: "Service / Machine" },
-            ],
-            tree_structure: "logic_equal(query(<host_field_query>, object: { identifier: 0 }), identifier[1] or context(Signer))",
-        },
-        constraints: [
-            "The Host Object must not be published (bPublished=false) when creating and binding the Guard",
-            "Use the Host Object name (not address) in the table; the SDK resolves it at binding time",
-            "The Host Object can only be published after the Guard is bound",
-            "Guard verification only runs normally after the Host Object is published",
-            "Use guard2file to export Guard backups for easy rebuilding",
-        ],
-        example: {
-            root: {
-                type: "logic_equal",
-                nodes: [
-                    {
-                        type: "query",
-                        query: 1231,
-                        object: { identifier: 0 },
-                        parameters: [],
-                    },
-                    { type: "identifier", identifier: 1 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "my_service", name: "Host Service name (circular reference, resolved by SDK at binding time)" },
-                { identifier: 1, b_submission: false, value_type: "Bool", value: false, name: "Expected Service paused state (false=not paused)" },
-            ],
-        },
-    },
-    {
-        id: "P17",
-        pattern_name: "Query parameter translation pattern (type conversion node combination)",
-        data_source_combination: "Type1/2 + type conversion (query parameter type translation)",
-        semantic_intent: "Guard queries parameters that require type conversion (e.g. Address → U64 timestamp key); uses convert_* nodes to translate",
-        match_keywords: ["type conversion", "translate", "convert", "timestamp key", "parameter translation", "address to u64"],
-        schema_elements: {
-            root_type: "logic_equal / logic_as_u256_greater_or_equal",
-            table_entries: [
-                { value_type: "Address", b_submission: false, purpose: "Query target object address (Type1/2)" },
-                { value_type: "U64", b_submission: false, purpose: "Comparison baseline value (e.g. timestamp threshold)" },
-            ],
-            query_nodes: [
-                { query_name: "query_repository_data / query_progress_history_*", object_type: "Repository / Progress" },
-            ],
-            tree_structure: "logic_as_u256_greater_or_equal(query(<query_with_converted_param>, object: { identifier: 0 }, parameters: [convert_number_address(identifier[1])]), identifier[2])",
-        },
-        constraints: [
-            "The query parameter type must match the parameters type defined in GUARDQUERY",
-            "If the table declares Address but the query requires U64, convert_number_address must be used to translate",
-            "The input type of convert_* nodes must be compatible with the child node's return type",
-            "The translated type must match the parameters definition of the query instruction",
-            "Use wowok_buildin_info info='guard instructions' to verify parameter types",
-        ],
-        example: {
-            root: {
-                type: "logic_as_u256_greater_or_equal",
-                nodes: [
-                    {
-                        type: "query",
-                        query: 1167,
-                        object: { identifier: 0 },
-                        parameters: [
-                            {
-                                type: "convert_number_address",
-                                nodes: [
-                                    { type: "identifier", identifier: 1 },
-                                ],
-                            },
-                        ],
-                    },
-                    { type: "identifier", identifier: 2 },
-                ],
-            },
-            table: [
-                { identifier: 0, b_submission: false, value_type: "Address", value: "0xrepo", name: "Repository address constant" },
-                { identifier: 1, b_submission: false, value_type: "U64", value: 1700000000000, name: "Timestamp key (U64, needs to be converted to Address for Repository query)" },
-                { identifier: 2, b_submission: false, value_type: "U256", value: 100, name: "Expected Repository data value" },
-            ],
-        },
-    },
-];
-export const SCHEMA_TO_SEMANTIC_RULES = [
-    { element_type: "node", type_name: "logic_equal", semantic: "Equality comparison (==), returns Bool. Accepts any type but both operands must be type-compatible", return_type: "Bool", child_constraints: "2 child nodes, types must be compatible" },
-    { element_type: "node", type_name: "logic_not", semantic: "Logical NOT (!), returns Bool", return_type: "Bool", child_constraints: "1 child node, must be Bool" },
-    { element_type: "node", type_name: "logic_and", semantic: "Logical AND; true if all child nodes are true", return_type: "Bool", child_constraints: "2-8 Bool child nodes (MAX_MULTI_OPERANDS)" },
-    { element_type: "node", type_name: "logic_or", semantic: "Logical OR; true if any child node is true", return_type: "Bool", child_constraints: "2-8 Bool child nodes" },
-    { element_type: "node", type_name: "logic_as_u256_greater", semantic: "Numeric greater than (>), auto-widened to U256", return_type: "Bool", child_constraints: "2 numeric child nodes (U8-U256 compatible)" },
-    { element_type: "node", type_name: "logic_as_u256_lesser", semantic: "Numeric less than (<)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "logic_as_u256_equal", semantic: "Numeric equality (==)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "logic_as_u256_greater_or_equal", semantic: "Numeric greater than or equal (>=)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "logic_as_u256_lesser_or_equal", semantic: "Numeric less than or equal (<=)", return_type: "Bool", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "logic_string_contains", semantic: "String contains (case-sensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "logic_string_nocase_contains", semantic: "String contains (case-insensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "logic_string_nocase_equal", semantic: "String equality (case-insensitive)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "identifier", semantic: "References the value of a table entry. The data source type depends on b_submission: false=Type1 constant, true=Type3 submitted", return_type: "Determined by table entry value_type", child_constraints: "No child nodes; requires identifier field to reference table", data_source_class: "Type1_OnChainConstant" },
-    { element_type: "node", type_name: "context", semantic: "Transaction context data (Type4 SystemContext). Signer=signer address, Clock=on-chain timestamp (U64), Guard=ObjectID of the Guard currently being verified", return_type: "Address (Signer/Guard) / U64 (Clock)", child_constraints: "No child nodes", data_source_class: "Type4_SystemContext" },
-    { element_type: "node", type_name: "query", semantic: "Queries on-chain object data. The data source type depends on object.convert_witness: present=Type2 (witness-derived), absent+constant=Type1, absent+submitted=Type3", return_type: "Determined by the query instruction", child_constraints: "Requires query + object + parameters fields", data_source_class: "Type1_OnChainConstant", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
-    { element_type: "node", type_name: "calc_number_add", semantic: "Numeric addition", return_type: "U256", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "calc_number_subtract", semantic: "Numeric subtraction", return_type: "U256", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "calc_number_multiply", semantic: "Numeric multiplication", return_type: "U256", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "calc_number_divide", semantic: "Numeric division", return_type: "U256", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "calc_number_mod", semantic: "Numeric modulo", return_type: "U256", child_constraints: "2 numeric child nodes" },
-    { element_type: "node", type_name: "calc_string_length", semantic: "String length", return_type: "U64", child_constraints: "1 String child node" },
-    { element_type: "node", type_name: "calc_string_contains", semantic: "String contains (returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "calc_string_nocase_contains", semantic: "String contains (case-insensitive, returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "calc_string_nocase_equal", semantic: "String equality (case-insensitive, returns Bool)", return_type: "Bool", child_constraints: "2 String child nodes" },
-    { element_type: "node", type_name: "calc_string_indexof", semantic: "String find index", return_type: "U64", child_constraints: "2 String child nodes + order" },
-    { element_type: "node", type_name: "calc_string_nocase_indexof", semantic: "String find index (case-insensitive)", return_type: "U64", child_constraints: "2 String child nodes + order" },
-    { element_type: "node", type_name: "convert_number_address", semantic: "Number → Address conversion (e.g. timestamp to address)", return_type: "Address", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_address_number", semantic: "Address → Number conversion", return_type: "U256", child_constraints: "1 Address child node" },
-    { element_type: "node", type_name: "convert_number_string", semantic: "Number → String conversion", return_type: "String", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_string_number", semantic: "String → Number conversion", return_type: "U256", child_constraints: "1 String child node" },
-    { element_type: "node", type_name: "convert_safe_u8", semantic: "Safe conversion to U8 (errors on overflow)", return_type: "U8", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_safe_u16", semantic: "Safe conversion to U16", return_type: "U16", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_safe_u32", semantic: "Safe conversion to U32", return_type: "U32", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_safe_u64", semantic: "Safe conversion to U64", return_type: "U64", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_safe_u128", semantic: "Safe conversion to U128", return_type: "U128", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "convert_safe_u256", semantic: "Safe conversion to U256", return_type: "U256", child_constraints: "1 numeric child node" },
-    { element_type: "node", type_name: "value_type", semantic: "Returns the value's type identifier (U8) — used for dynamic type checking", return_type: "U8", child_constraints: "1 variable child node" },
-    { element_type: "node", type_name: "vec_length", semantic: "Vector length", return_type: "U64", child_constraints: "1 vec child node" },
-    { element_type: "node", type_name: "vec_contains_bool", semantic: "Whether the vector contains a Bool value", return_type: "Bool", child_constraints: "1 VecBool + 1 Bool" },
-    { element_type: "node", type_name: "vec_contains_address", semantic: "Whether the vector contains an Address (whitelist check)", return_type: "Bool", child_constraints: "1 VecAddress + 1 Address" },
-    { element_type: "node", type_name: "vec_contains_string", semantic: "Whether the vector contains a String", return_type: "Bool", child_constraints: "1 VecString + 1 String" },
-    { element_type: "node", type_name: "vec_contains_string_nocase", semantic: "Whether the vector contains a String (case-insensitive)", return_type: "Bool", child_constraints: "1 VecString + 1 String" },
-    { element_type: "node", type_name: "vec_contains_number", semantic: "Whether the vector contains a number", return_type: "Bool", child_constraints: "1 Vec* + 1 Number" },
-    { element_type: "node", type_name: "vec_indexof_bool", semantic: "Bool vector find index", return_type: "U64", child_constraints: "VecBool + Bool + order" },
-    { element_type: "node", type_name: "vec_indexof_address", semantic: "Address vector find index", return_type: "U64", child_constraints: "VecAddress + Address + order" },
-    { element_type: "node", type_name: "vec_indexof_string", semantic: "String vector find index", return_type: "U64", child_constraints: "VecString + String + order" },
-    { element_type: "node", type_name: "vec_indexof_string_nocase", semantic: "String vector find index (case-insensitive)", return_type: "U64", child_constraints: "VecString + String + order" },
-    { element_type: "node", type_name: "vec_indexof_number", semantic: "Numeric vector find index", return_type: "U64", child_constraints: "Vec* + Number + order" },
-    { element_type: "node", type_name: "query_reward_record_find", semantic: "Query reward claim records (returns the found record)", return_type: "Bool", child_constraints: "Requires object + recipient + where + find" },
-    { element_type: "node", type_name: "query_reward_record_count", semantic: "Query reward claim record count (U64)", return_type: "U64", child_constraints: "Requires object + recipient (optional)" },
-    { element_type: "node", type_name: "query_reward_record_exists", semantic: "Query whether a reward claim record exists (Bool)", return_type: "Bool", child_constraints: "Requires object + recipient (optional)" },
-    { element_type: "node", type_name: "query_progress_history_find", semantic: "Query whether a specified session exists in Progress history", return_type: "Bool", child_constraints: "Requires object + where + find" },
-    { element_type: "node", type_name: "query_progress_history_session_find", semantic: "Query a Progress session", return_type: "Bool", child_constraints: "Requires object + historyIdx + where + find" },
-    { element_type: "node", type_name: "query_progress_history_session_forward_find", semantic: "Query whether a specified forward exists in a Progress session", return_type: "Bool", child_constraints: "Requires object + historyIdx + sessionIdx + where + find" },
-    { element_type: "node", type_name: "query_progress_history_session_count", semantic: "Query the number of Progress sessions", return_type: "U64", child_constraints: "Requires object + historyIdx" },
-    { element_type: "node", type_name: "query_progress_history_session_forward_count", semantic: "Query the number of forwards in a Progress session", return_type: "U64", child_constraints: "Requires object + historyIdx + sessionIdx" },
-    { element_type: "node", type_name: "query_progress_history_session_forward_retained_submission_count", semantic: "Query the retained submission count of a forward in a Progress session", return_type: "U64", child_constraints: "Requires object + historyIdx + sessionIdx + forwardIdx" },
-    { element_type: "witness", type_name: "TypeOrderProgress", semantic: "Reads the order.progress field from an Order address to derive Progress (100, single hop)", data_source_class: "Type2_WitnessDerived", discovery_tool: "wowok_buildin_info(info='guard instructions')" },
-    { element_type: "witness", type_name: "TypeOrderMachine", semantic: "Reads the order.machine field from an Order address to derive Machine (101, single hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeOrderService", semantic: "Reads the order.service field from an Order address to derive Service (102, single hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeProgressMachine", semantic: "Reads the progress.machine field from a Progress address to derive Machine (103, single hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeArbOrder", semantic: "Reads the arb.order field from an Arb address to derive Order (104, single hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeArbArbitration", semantic: "Reads the arb.arbitration field from an Arb address to derive the parent Arbitration service (105, single hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeArbProgress", semantic: "Derives from Arb in two hops: arb.order → order.progress (106, multi-hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeArbMachine", semantic: "Derives from Arb in two hops: arb.order → order.machine (107, multi-hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "witness", type_name: "TypeArbService", semantic: "Derives from Arb in two hops: arb.order → order.service (108, multi-hop)", data_source_class: "Type2_WitnessDerived" },
-    { element_type: "context", type_name: "Signer", semantic: "Current transaction signer address (TransactionContext.sender())", return_type: "Address", data_source_class: "Type4_SystemContext" },
-    { element_type: "context", type_name: "Clock", semantic: "Current on-chain timestamp (reads timestamp_ms of WOW_CLOCK_OBJECT_ID 0x6)", return_type: "U64", data_source_class: "Type4_SystemContext" },
-    { element_type: "context", type_name: "Guard", semantic: "ObjectID of the Guard object currently being verified (self-reference, rare)", return_type: "Address", data_source_class: "Type4_SystemContext" },
-    { element_type: "table_entry", type_name: "Bool", semantic: "Boolean constant or submission" },
-    { element_type: "table_entry", type_name: "Address", semantic: "Address constant (Type1) or submission (Type3). Object address type" },
-    { element_type: "table_entry", type_name: "String", semantic: "String constant or submission" },
-    { element_type: "table_entry", type_name: "U8", semantic: "8-bit unsigned integer" },
-    { element_type: "table_entry", type_name: "U16", semantic: "16-bit unsigned integer" },
-    { element_type: "table_entry", type_name: "U32", semantic: "32-bit unsigned integer" },
-    { element_type: "table_entry", type_name: "U64", semantic: "64-bit unsigned integer (commonly used for timestamps)" },
-    { element_type: "table_entry", type_name: "U128", semantic: "128-bit unsigned integer" },
-    { element_type: "table_entry", type_name: "U256", semantic: "256-bit unsigned integer (auto-widening target for numeric operations)" },
-    { element_type: "table_entry", type_name: "VecAddress", semantic: "Address vector (used for whitelists, Type1 constant)" },
-    { element_type: "table_entry", type_name: "VecString", semantic: "String vector" },
-    { element_type: "table_entry", type_name: "VecU64", semantic: "U64 vector" },
-    { element_type: "table_entry", type_name: "VecU8", semantic: "U8 vector (raw bytes)" },
-    { element_type: "table_entry", type_name: "Value", semantic: "Dynamic type (19, first byte is the type identifier) — used for Repository data, EntityRegistrar records, Passport submission value" },
-    { element_type: "rely", type_name: "rely_and", semantic: "Depends on other Guards, AND logic (all must pass). Depended-on Guards must have rep=true", child_constraints: "At most 4 dependencies, each with rep=true (repository.data query does not depend on submission)" },
-    { element_type: "rely", type_name: "rely_or", semantic: "Depends on other Guards, OR logic (any one passing is sufficient). Depended-on Guards must have rep=true", child_constraints: "At most 4 dependencies, each with rep=true" },
-];
-export const GUARD_CONSTRAINT_RULES = [
-    {
-        id: "ROOT_01",
-        name: "root returns Bool",
-        description: "The Guard root node must return a Bool type",
-        category: "root",
-        phase: "creation",
-        validation_logic: "root.node_type must be in the allowedTypes list (logic_*, calc_string_contains, vec_contains_*, query_reward_record_exists, query[Bool return], identifier[Bool type])",
-        failure_message: "Guard root node must be an operation that returns Bool",
-        verification_location: "SDK buildNode(root, ValueType.Bool, ...)",
-        pitfall_number: 7,
-    },
-    {
-        id: "TABLE_01",
-        name: "identifier uniqueness",
-        description: "Each identifier in the table must be unique (0-255)",
-        category: "table",
-        phase: "creation",
-        validation_logic: "No duplicate identifiers in the table",
-        failure_message: "Duplicate table identifier",
-        verification_location: "SDK lodash groupBy",
-    },
-    {
-        id: "TABLE_02",
-        name: "identifier referential integrity",
-        description: "Every identifier node in the computation tree must exist in the table",
-        category: "table",
-        phase: "creation",
-        validation_logic: "Traverse the computation tree; each identifier node's index exists in the table",
-        failure_message: "Identifier not found in table",
-        verification_location: "SDK buildNode",
-        pitfall_number: 1,
-    },
-    {
-        id: "TABLE_03",
-        name: "Constant entries must have a value",
-        description: "Entries with b_submission=false must have a value field",
-        category: "table",
-        phase: "creation",
-        validation_logic: "All entries with b_submission=false have a non-empty value field",
-        failure_message: "Constant table entry must have a value",
-        verification_location: "SDK operate",
-    },
-    {
-        id: "TABLE_04",
-        name: "table size limit",
-        description: "At most 256 entries; serialized size must not exceed 40000 bytes",
-        category: "table",
-        phase: "creation",
-        validation_logic: "table.length <= 256 && serialize(table).length <= 40000",
-        failure_message: "Table exceeds size limit (256 entries or 40000 bytes)",
-        verification_location: "Move guard::new",
-    },
-    {
-        id: "TABLE_05",
-        name: "submission entry value is 1 byte (type code only)",
-        description: "Entries with b_submission=true have a serialized value of just 1 byte (the type code)",
-        category: "table",
-        phase: "creation",
-        validation_logic: "When b_submission=true, bcsValue.length === 1 and bcsValue[0] === valueType",
-        failure_message: "Submission table entry value must be 1 byte (type code only)",
-        verification_location: "native deserialize_constants",
-    },
-    {
-        id: "QUERY_01",
-        name: "query instruction valid",
-        description: "The query field of a query node must be a valid GUARDQUERY ID or name",
-        category: "query",
-        phase: "creation",
-        validation_logic: "The query field exists in GUARDQUERY (via isValidGuardQueryIdOrName)",
-        failure_message: "Invalid Guard query instruction",
-        verification_location: "SDK getGuardQueryInfo",
-        pitfall_number: 3,
-    },
-    {
-        id: "QUERY_02",
-        name: "query parameter count match",
-        description: "The number and types of parameters in a query node must match the instruction definition",
-        category: "query",
-        phase: "creation",
-        validation_logic: "parameters.length === instruction.parameters.length && type-compatible",
-        failure_message: "Query parameter count or type mismatch",
-        verification_location: "SDK buildNode",
-        pitfall_number: 3,
-    },
-    {
-        id: "QUERY_03",
-        name: "query return type compatible",
-        description: "The return type of a query node must be compatible with the parent node's expected type",
-        category: "query",
-        phase: "creation",
-        validation_logic: "checkType(query.return_type, parent.expected_type)",
-        failure_message: "Query return type incompatible with parent node",
-        verification_location: "SDK checkType",
-    },
-    {
-        id: "QUERY_04",
-        name: "query object identifier's value_type is Address",
-        description: "The table entry referenced by query node's object.identifier must have value_type of Address",
-        category: "query",
-        phase: "creation",
-        validation_logic: "table[object.identifier].value_type === Address",
-        failure_message: "Query object identifier must reference an Address-type table entry",
-        verification_location: "SDK buildNode L603-609",
-    },
-    {
-        id: "WITNESS_01",
-        name: "witness type valid",
-        description: "convert_witness must be a valid WitnessType (100-108)",
-        category: "witness",
-        phase: "creation",
-        validation_logic: "The witness value is within the range allowed by WitnessTypeSchema (100-108)",
-        failure_message: "Invalid witness type",
-        verification_location: "SDK isWitnessType",
-        pitfall_number: 4,
-    },
-    {
-        id: "WITNESS_02",
-        name: "witness target matches query objectType",
-        description: "The witness's target type must match the query instruction's objectType",
-        category: "witness",
-        phase: "creation",
-        validation_logic: "witness.target_type === instruction.objectType",
-        failure_message: "Witness target type does not match query object type",
-        verification_location: "SDK buildNode L613-619",
-        pitfall_number: 4,
-    },
-    {
-        id: "WITNESS_03",
-        name: "witness source matches tableItem object_type",
-        description: "The witness's source type must match the object_type declared in the table entry (if declared)",
-        category: "witness",
-        phase: "creation",
-        validation_logic: "table[identifier].object_type === witness.source_type (if tableItem.object_type is declared)",
-        failure_message: "Witness source type does not match table entry object_type",
-        verification_location: "SDK buildNode L622-631",
-        pitfall_number: 4,
-    },
-    {
-        id: "RELY_01",
-        name: "rely dependency count ≤ 4",
-        description: "rely.guards supports at most 4 dependencies (MAX_DEPENDED_COUNT)",
-        category: "rely",
-        phase: "creation",
-        validation_logic: "rely.guards.length <= 4",
-        failure_message: "Rely dependencies exceed limit (4)",
-        verification_location: "SDK reliesAdd",
-    },
-    {
-        id: "RELY_02",
-        name: "rely dependency rep=true",
-        description: "All rely-depended Guards must have rep=true (repository.data query does not depend on runtime submission)",
-        category: "rely",
-        phase: "creation",
-        validation_logic: "Query each depended Guard's rep field; must be true",
-        failure_message: "Rely dependency has rep=false (not standalone)",
-        verification_location: "Move guard::relies_add",
-        pitfall_number: 8,
-    },
-    {
-        id: "RELY_03",
-        name: "rely forbids self-reference",
-        description: "A Guard cannot depend on itself",
-        category: "rely",
-        phase: "creation",
-        validation_logic: "rely.guards does not contain the current Guard's address",
-        failure_message: "Guard cannot rely on itself",
-        verification_location: "SDK reliesAdd",
-    },
-    {
-        id: "BINDING_01",
-        name: "voting_guard GuardIdentifier numeric",
-        description: "The table entry referenced by Arbitration voting_guard's GuardIdentifier must be of a numeric type",
-        category: "binding",
-        phase: "creation",
-        validation_logic: "If binding=voting_guard, the table entry pointed to by GuardIdentifier has value_type in [U8,U16,U32,U64,U128,U256]",
-        failure_message: "E_GUARD_IDENTIFIER_NOT_NUMBER: voting_guard weight must be numeric",
-        verification_location: "Move Arbitration",
-        pitfall_number: 9,
-    },
-    {
-        id: "BINDING_02",
-        name: "Repository id_from_submission Address",
-        description: "The table entry referenced by Repository write_guard's id_from_submission must be of Address type",
-        category: "binding",
-        phase: "creation",
-        validation_logic: "If binding=write_guard and id_from_submission is set, table[id_from_submission].value_type === Address",
-        failure_message: "Repository id_from_submission must be Address type",
-        verification_location: "Move Repository",
-    },
-    {
-        id: "BINDING_03",
-        name: "Repository data_from_submission type match",
-        description: "The table entry referenced by Repository write_guard's data_from_submission must match the Repository value_type",
-        category: "binding",
-        phase: "creation",
-        validation_logic: "If binding=write_guard and data_from_submission is set, table[data_from_submission].value_type === Repository.value_type",
-        failure_message: "Repository data_from_submission type mismatch",
-        verification_location: "Move Repository",
-    },
-    {
-        id: "INPUT_01",
-        name: "root byte stream non-empty",
-        description: "The serialized byte stream of root cannot be empty",
-        category: "input",
-        phase: "creation",
-        validation_logic: "input.length > 0",
-        failure_message: "Input cannot be empty",
-        verification_location: "SDK newGuard",
-    },
-    {
-        id: "INPUT_02",
-        name: "root byte stream ≤ MAX_INPUT_SIZE",
-        description: "The serialized byte stream of root must not exceed MAX_INPUT_SIZE",
-        category: "input",
-        phase: "creation",
-        validation_logic: "input.length <= MAX_INPUT_SIZE",
-        failure_message: "Input size exceeds maximum limit",
-        verification_location: "SDK newGuard",
-    },
-    {
-        id: "IMMUTABLE_01",
-        name: "Guard immutable=true after creation",
-        description: "After creation, a Guard cannot be modified or deleted (CREATE-only)",
-        category: "immutable",
-        phase: "creation",
-        validation_logic: "After guard::create, the immutable field is set to true",
-        failure_message: "Guard is immutable after creation",
-        verification_location: "Move guard::create",
-    },
-    {
-        id: "RUN_IMMUTABLE_01",
-        name: "Guard must be immutable=true to verify",
-        description: "At runtime verification, the Guard must be frozen (immutable=true)",
-        category: "immutable",
-        phase: "runtime",
-        validation_logic: "guard.immutable === true",
-        failure_message: "Guard must be immutable to verify",
-        verification_location: "native verify_guard L497-506",
-    },
-    {
-        id: "RUN_SUB_01",
-        name: "submission type byte matches table declaration",
-        description: "The value[0] (type byte) of submission must match the value_type declared in the table",
-        category: "table",
-        phase: "runtime",
-        validation_logic: "submission_value[0] === table[identifier].value_type",
-        failure_message: "Submission type byte does not match table declaration",
-        verification_location: "native parse_table_items L306",
-    },
-    {
-        id: "RUN_SUB_02",
-        name: "table entries with b_submission=true must be found in submission",
-        description: "All table entries declared as submitted must have corresponding submission data",
-        category: "table",
-        phase: "runtime",
-        validation_logic: "forall identifier in table where b_submission=true: identifier in submission_map",
-        failure_message: "Missing submission for declared b_submission=true table entry",
-        verification_location: "native parse_table_items L301-321",
-    },
-    {
-        id: "RUN_SUB_03",
-        name: `submission total bytes ≤ MAX_SUBMISSION_SIZE_PASSPORT (${MAX_SUBMISSION_SIZE_PASSPORT})`,
-        description: `The total bytes of all data submitted at runtime must not exceed ${MAX_SUBMISSION_SIZE_PASSPORT}`,
-        category: "table",
-        phase: "runtime",
-        validation_logic: `total_submission_bytes <= ${MAX_SUBMISSION_SIZE_PASSPORT}`,
-        failure_message: `Submission exceeds MAX_SUBMISSION_SIZE_PASSPORT (${MAX_SUBMISSION_SIZE_PASSPORT} bytes)`,
-        verification_location: "Move verify L252",
-    },
-    {
-        id: "RUN_WITNESS_01",
-        name: "witness derivation source object must have the required relation field",
-        description: "When witness conversion occurs, the source object must contain the relation field needed for derivation",
-        category: "witness",
-        phase: "runtime",
-        validation_logic: "The source object exists and contains the field required for witness derivation (e.g. order.progress field is non-empty)",
-        failure_message: "Witness source object missing required field for derivation",
-        verification_location: "native convert_witness",
-    },
-    {
-        id: "RUN_WITNESS_02",
-        name: "witness-derived target object must exist",
-        description: "The target object derived by witness must exist on-chain",
-        category: "witness",
-        phase: "runtime",
-        validation_logic: "The derived target object ID exists on-chain",
-        failure_message: "Witness derived target object does not exist",
-        verification_location: "native convert_witness",
-    },
-    {
-        id: "RUN_QUERY_01",
-        name: "query target object must exist and type match",
-        description: "The target object of a query must exist on-chain and its type must match",
-        category: "query",
-        phase: "runtime",
-        validation_logic: "Target object exists && object type matches query.objectType",
-        failure_message: "Query target object does not exist or type mismatch",
-        verification_location: "native process_object_query",
-    },
-    {
-        id: "RUN_IMPACK_01",
-        name: "at least one impack guard",
-        description: "Passport verification requires at least one impack guard",
-        category: "runtime",
-        phase: "runtime",
-        validation_logic: "impack_list.length >= 1 (note: impack_list is always empty during verify phase; this constraint is checked in result_for_permission phase)",
-        failure_message: "No impack guard found",
-        verification_location: "Move verify L281",
-    },
-    {
-        id: "RUN_IMPACK_02",
-        name: "impack guard failure fails the entire passport",
-        description: "If any impack guard verification fails, the entire passport verification fails",
-        category: "runtime",
-        phase: "runtime",
-        validation_logic: "forall guard in impack_list: guard.result === true",
-        failure_message: "Impack guard verification failed",
-        verification_location: "Move verify L270-275",
-    },
-    {
-        id: "RUN_TX_01",
-        name: "Passport tx_hash must match the current transaction",
-        description: "The tx_hash recorded in the Passport must match the hash of the currently executing transaction",
-        category: "runtime",
-        phase: "runtime",
-        validation_logic: "passport.tx_hash === current_tx_hash",
-        failure_message: "Passport tx_hash does not match current transaction",
-        verification_location: "Move verify L231",
-    },
-    {
-        id: "RUN_RELY_01",
-        name: "rely guard must have been added to passport",
-        description: "Guards relied on must have been registered in the passport",
-        category: "rely",
-        phase: "runtime",
-        validation_logic: "forall guard in rely.guards: guard in passport.relies",
-        failure_message: "Rely guard not added to passport",
-        verification_location: "Move calculate_relies_result",
-    },
-];
-export function matchSemanticPattern(userIntent) {
-    const lower = userIntent.toLowerCase();
-    return SEMANTIC_TO_SCHEMA_RULES.filter((rule) => rule.match_keywords.some((kw) => lower.includes(kw.toLowerCase())));
-}
-export function explainNode(nodeType) {
-    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "node" && r.type_name === nodeType);
-}
-export function explainWitness(witnessType) {
-    const witnessMap = {
-        100: "TypeOrderProgress",
-        101: "TypeOrderMachine",
-        102: "TypeOrderService",
-        103: "TypeProgressMachine",
-        104: "TypeArbOrder",
-        105: "TypeArbArbitration",
-        106: "TypeArbProgress",
-        107: "TypeArbMachine",
-        108: "TypeArbService",
-    };
-    const name = witnessMap[witnessType];
-    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "witness" && r.type_name === name);
-}
-export function explainContext(contextType) {
-    return SCHEMA_TO_SEMANTIC_RULES.find((r) => r.element_type === "context" && r.type_name === contextType);
-}
-export function getConstraintsByCategory(category) {
-    return GUARD_CONSTRAINT_RULES.filter((r) => r.category === category);
-}
-export function getConstraintsByPhase(phase) {
-    return GUARD_CONSTRAINT_RULES.filter((r) => r.phase === phase);
-}
-export function getPatternById(id) {
-    return SEMANTIC_TO_SCHEMA_RULES.find((r) => r.id === id);
-}
-export function getDataSourceCombinations() {
-    return [...new Set(SEMANTIC_TO_SCHEMA_RULES.map((r) => r.data_source_combination))];
-}
+import{MAX_SUBMISSION_SIZE_PASSPORT}from'@wowok/wowok';export const SEMANTIC_TO_SCHEMA_RULES=[{'id':'P02','pattern_name':'Query\x20published\x20object\x20+\x20system\x20context','data_source_combination':'Type1\x20+\x20Type4','semantic_intent':'Query\x20published\x20on-chain\x20object\x20fields\x20and\x20compare\x20with\x20system\x20context','match_keywords':['paused','published','service\x20status','machine\x20status','paused','published'],'schema_elements':{'root_type':'logic_equal\x20/\x20logic_and','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'Published\x20object\x20address\x20constant\x20(Type1)'}],'context_nodes':[{'context_type':'Signer','purpose':'Optional:\x20identity\x20validation'}],'tree_structure':'logic_equal(query(<instruction>,\x20object:\x20{\x20identifier:\x200\x20}),\x20identifier[1]\x20or\x20context(Signer))'},'constraints':['The\x20object_type\x20of\x20table[0]\x20must\x20match\x20the\x20target\x20object\x20type\x20of\x20the\x20query\x20instruction','The\x20query\x20return\x20type\x20must\x20be\x20compatible\x20with\x20the\x20comparison\x20object','The\x20object\x20must\x20be\x20published\x20(published=true)\x20to\x20ensure\x20fields\x20are\x20immutable'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query','query':'service.paused','object':{'identifier':0x0},'parameters':[]},{'type':'identifier','identifier':0x1}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'0xSERVICE','name':'Service\x20object\x20address'},{'identifier':0x1,'b_submission':![],'value_type':'Bool','value':![],'name':'Expected\x20paused\x20state\x20(false=not\x20paused)'}]}},{'id':'P03','pattern_name':'Identity\x20check\x20(single\x20address)','data_source_combination':'Type4\x20+\x20Type1\x20constant','semantic_intent':'Only\x20a\x20specific\x20address\x20can\x20perform\x20the\x20operation','match_keywords':['only','allow','authorize','identity','specified\x20address','signer'],'schema_elements':{'root_type':'logic_equal','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'Authorized\x20address\x20constant\x20(Type1\x20constant)'}],'context_nodes':[{'context_type':'Signer','purpose':'Current\x20transaction\x20signer\x20(Type4)'}],'tree_structure':'logic_equal(context(Signer),\x20identifier[0])'},'constraints':['root\x20must\x20be\x20logic_equal\x20(returns\x20Bool)','table[0]\x20must\x20be\x20Address\x20type,\x20b_submission=false','context(Signer)\x20returns\x20the\x20current\x20transaction\x20signer\x20address'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'context','context':'Signer'},{'type':'identifier','identifier':0x0}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'0xabc...','name':'Authorized\x20operator\x20address'}]}},{'id':'P04','pattern_name':'Identity\x20check\x20(whitelist)','data_source_combination':'Type4\x20+\x20Type1\x20constant\x20(VecAddress)','semantic_intent':'Addresses\x20in\x20the\x20whitelist\x20can\x20perform\x20this\x20operation','match_keywords':['whitelist','multiple\x20addresses','list','allowlist','roster'],'schema_elements':{'root_type':'vec_contains_address','table_entries':[{'value_type':'VecAddress','b_submission':![],'purpose':'Authorized\x20address\x20list\x20(Type1\x20constant)'}],'context_nodes':[{'context_type':'Signer','purpose':'Signer\x20being\x20looked\x20up\x20(Type4)'}],'tree_structure':'vec_contains_address(identifier[0],\x20context(Signer))'},'constraints':['root\x20vec_contains_address\x20returns\x20Bool','table[0]\x20must\x20be\x20VecAddress\x20type','context(Signer)\x20is\x20the\x20element\x20being\x20looked\x20up'],'example':{'root':{'type':'vec_contains_address','nodes':[{'type':'identifier','identifier':0x0},{'type':'context','context':'Signer'}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'VecAddress','value':['0xabc...','0xdef...'],'name':'Authorized\x20address\x20whitelist'}]}},{'id':'P05','pattern_name':'Time\x20lock','data_source_combination':'Type2\x20+\x20Type4\x20+\x20Type1\x20constant','semantic_intent':'This\x20operation\x20can\x20only\x20be\x20executed\x20after\x20waiting\x20N\x20milliseconds','match_keywords':['wait','time','lock','delay','hours','days','milliseconds'],'schema_elements':{'root_type':'logic_as_u256_greater_or_equal','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Source\x20object\x20address\x20(e.g.\x20Order,\x20Type3)\x20or\x20constant\x20(Type1)'},{'value_type':'U64','b_submission':![],'purpose':'Lock\x20duration\x20(in\x20milliseconds,\x201000\x20for\x20tests,\x20Type1\x20constant)'}],'query_nodes':[{'query_name':'progress.current_time','object_type':'Progress','convert_witness':0x64}],'context_nodes':[{'context_type':'Clock','purpose':'Current\x20on-chain\x20timestamp\x20(Type4)'}],'tree_structure':'logic_as_u256_greater_or_equal(context(Clock),\x20calc_number_add(query(1272:\x20progress.current_time,\x20witness=100,\x20identifier[0]),\x20identifier[1]))'},'constraints':['Time\x20unit\x20is\x20milliseconds;\x20use\x201000ms\x20for\x20tests\x20and\x20adjust\x20in\x20production','convert_witness=100\x20(TypeOrderProgress)\x20converts\x20from\x20Order\x20to\x20Progress','The\x20object_type\x20of\x20table[0]\x20must\x20match\x20the\x20witness\x20source\x20type\x20(Order)','calc_number_add\x20returns\x20U256,\x20context(Clock)\x20returns\x20U64,\x20auto-widened','Key:\x20use\x20progress.current_time(1272)\x20rather\x20than\x20progress.session.forward.time(1271);\x20the\x20latter\x20querying\x20an\x20unforwarded\x20session\x20returns\x200\x20and\x20disables\x20the\x20time\x20lock'],'example':{'root':{'type':'logic_as_u256_greater_or_equal','nodes':[{'type':'context','context':'Clock'},{'type':'calc_number_add','nodes':[{'type':'query','query':'progress.current_time','object':{'identifier':0x0,'convert_witness':0x64},'parameters':[]},{'type':'identifier','identifier':0x1}]}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'Target\x20Order\x20address','object_type':'Order'},{'identifier':0x1,'b_submission':![],'value_type':'U64','value':0x3e8,'name':'Lock\x20duration\x20(milliseconds)'}]}},{'id':'P06','pattern_name':'Progress\x20state\x20check','data_source_combination':'Type2\x20+\x20Type1\x20constant','semantic_intent':'The\x20order\x20progress\x20must\x20reach\x20the\x20specified\x20node\x20before\x20this\x20operation\x20can\x20be\x20executed','match_keywords':['progress','node','state','completed','reach','current\x20node'],'schema_elements':{'root_type':'logic_equal','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Source\x20Order\x20address\x20(Type3,\x20witness\x20source)'},{'value_type':'String','b_submission':![],'purpose':'Expected\x20node\x20name\x20(Type1\x20constant)'}],'query_nodes':[{'query_name':'progress.current','object_type':'Progress','convert_witness':0x64}],'tree_structure':'logic_equal(query(1253:\x20progress.current,\x20witness=100,\x20identifier[0]),\x20identifier[1])'},'constraints':['query\x20returns\x20String;\x20identifier[1]\x20must\x20be\x20String\x20type','logic_equal\x20comparison\x20on\x20String\x20is\x20case-sensitive','For\x20case-insensitive\x20comparison,\x20use\x20logic_string_nocase_equal','convert_witness=100\x20(TypeOrderProgress)\x20converts\x20from\x20Order','Type2\x20stacks\x20on\x20Type3:\x20the\x20source\x20object\x20Order\x20is\x20submitted\x20(b_submission=true)'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query','query':'progress.current','object':{'identifier':0x0,'convert_witness':0x64},'parameters':[]},{'type':'identifier','identifier':0x1}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'Target\x20Order\x20address','object_type':'Order'},{'identifier':0x1,'b_submission':![],'value_type':'String','value':'Completed','name':'Expected\x20progress\x20node\x20name'}]}},{'id':'P07','pattern_name':'One-time\x20claim\x20check','data_source_combination':'Type3\x20+\x20Type1\x20constant','semantic_intent':'Users\x20can\x20only\x20claim\x20the\x20reward\x20once','match_keywords':['once','claim','duplicate','already\x20claimed','claimed\x20before'],'schema_elements':{'root_type':'logic_equal','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Reward\x20object\x20address\x20(Type3,\x20submitted)'},{'value_type':'U64','b_submission':![],'purpose':'Expected\x20historical\x20claim\x20count\x200\x20(Type1\x20constant)'}],'query_nodes':[{'query_name':'reward.record.count','object_type':'Reward'}],'tree_structure':'logic_equal(query_reward_record_count(object:\x20{\x20identifier:\x200\x20},\x20recipient:\x20context(Signer)),\x20identifier[1])'},'constraints':['query_reward_record_count\x20returns\x20U64','Comparing\x20count\x20==\x200\x20means\x20no\x20history\x20record\x20(can\x20claim)','recipient\x20defaults\x20to\x20context(Signer)\x20to\x20ensure\x20the\x20claimer\x27s\x20identity\x20is\x20bound','Type3\x20submitted\x20objects\x20must\x20have\x20constraint\x20rules\x20(here\x20the\x20constraint\x20is\x20count==0\x20and\x20recipient=Signer)'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query_reward_record_count','object':{'identifier':0x0}},{'type':'identifier','identifier':0x1}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'Reward\x20object\x20address','object_type':'Reward'},{'identifier':0x1,'b_submission':![],'value_type':'U64','value':0x0,'name':'Expected\x20historical\x20claim\x20count\x20(0)'}]}},{'id':'P08','pattern_name':'Submitted\x20object\x20identity\x20validation','data_source_combination':'Type3\x20+\x20Type4','semantic_intent':'Verify\x20that\x20the\x20owner\x20of\x20the\x20submitted\x20object\x20matches\x20the\x20signer','match_keywords':['ownership','belonging','customer','submitted\x20object','order.customer'],'schema_elements':{'root_type':'logic_equal','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Submitted\x20Order\x20address\x20(Type3)'}],'context_nodes':[{'context_type':'Signer','purpose':'Current\x20signer\x20(Type4),\x20compared\x20with\x20order.customer'}],'query_nodes':[{'query_name':'order.customer','object_type':'Order'}],'tree_structure':'logic_equal(query(1550:\x20order.customer,\x20object:\x20{\x20identifier:\x200\x20}),\x20context(Signer))'},'constraints':['query\x20returns\x20Address,\x20context(Signer)\x20returns\x20Address,\x20types\x20compatible','Type3\x20submitted\x20object\x20constraint:\x20indirectly\x20binds\x20submitter\x20identity\x20via\x20order.customer\x20==\x20Signer','Ensures\x20callers\x20cannot\x20submit\x20other\x20users\x27\x20Order\x20addresses'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query','query':'order.customer','object':{'identifier':0x0},'parameters':[]},{'type':'context','context':'Signer'}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'User-submitted\x20Order\x20address','object_type':'Order'}]}},{'id':'P09','pattern_name':'Submitted\x20object\x20+\x20witness\x20derivation\x20query','data_source_combination':'Type3\x20+\x20Type2\x20(source\x20is\x20Type3)','semantic_intent':'User\x20submits\x20an\x20Order\x20and\x20queries\x20the\x20Progress\x20state\x20via\x20witness','match_keywords':['submit','derive','witness','order\x20to\x20progress','convert'],'schema_elements':{'root_type':'logic_equal\x20/\x20logic_and','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Submitted\x20Order\x20address\x20(Type3,\x20witness\x20source)'},{'value_type':'String','b_submission':![],'purpose':'Expected\x20node\x20name\x20(Type1\x20constant)'}],'query_nodes':[{'query_name':'progress.current','object_type':'Progress','convert_witness':0x64}],'tree_structure':'logic_equal(query(1253:\x20progress.current,\x20object:\x20{\x20identifier:\x200,\x20convert_witness:\x20100\x20}),\x20identifier[1])'},'constraints':['Type2\x20stacks\x20on\x20Type3:\x20the\x20source\x20object\x20Order\x20has\x20b_submission=true','witness=100\x20(TypeOrderProgress)\x20derives\x20Progress\x20from\x20the\x20submitted\x20Order','query\x20returns\x20String;\x20identifier[1]\x20must\x20be\x20String\x20type','Key:\x20Type2\x20can\x20stack\x20on\x20Type1\x20or\x20Type3,\x20depending\x20on\x20the\x20source\x20object\x27s\x20b_submission'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query','query':'progress.current','object':{'identifier':0x0,'convert_witness':0x64},'parameters':[]},{'type':'identifier','identifier':0x1}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'User-submitted\x20Order\x20address','object_type':'Order'},{'identifier':0x1,'b_submission':![],'value_type':'String','value':'Inspecting','name':'Expected\x20progress\x20node\x20name'}]}},{'id':'P10','pattern_name':'Multi-condition\x20combination\x20(AND/OR)','data_source_combination':'Type1\x20+\x20Type2\x20+\x20Type3\x20+\x20Type4\x20(combination)','semantic_intent':'Multiple\x20conditions\x20must\x20all\x20be\x20satisfied\x20(AND)\x20or\x20any\x20one\x20is\x20satisfied\x20(OR)','match_keywords':['and','simultaneously','all\x20satisfied','AND','and\x20also','also\x20need','or','any','OR','or','one\x20of'],'schema_elements':{'root_type':'logic_and\x20/\x20logic_or','table_entries':[],'tree_structure':'logic_and/logic_or([condition1,\x20condition2,\x20...])\x20—\x20each\x20condition\x20can\x20be\x20any\x20combination\x20of\x20P03-P09'},'constraints':['All\x20subnodes\x20of\x20logic_and/logic_or\x20must\x20return\x20Bool','Subnode\x20count\x202-8\x20(MAX_MULTI_OPERANDS)','Each\x20subcondition\x20can\x20be\x20any\x20node\x20that\x20returns\x20Bool','Multi-condition\x20combination\x20is\x20a\x20container\x20for\x20other\x20Patterns\x20and\x20does\x20not\x20stand\x20alone'],'example':{'root':{'type':'logic_and','nodes':[{},{}]}}},{'id':'P11','pattern_name':'Entity\x20registration\x20check','data_source_combination':'Type1\x20system\x20address\x20+\x20Type3','semantic_intent':'Verify\x20that\x20the\x20user\x20is\x20registered\x20in\x20the\x20entity\x20registrar','match_keywords':['register','entity','EntityRegistrar','member','certify'],'schema_elements':{'root_type':'logic_and','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'EntityRegistrar\x20system\x20address\x200xaab\x20(Type1\x20system\x20address)'},{'value_type':'Address','b_submission':!![],'purpose':'User\x20address\x20(Type3,\x20submitted)'}],'query_nodes':[{'query_name':'entity.registrar.records','object_type':'EntityRegistrar'}],'tree_structure':'logic_and(query(1760:\x20entity.registrar.records,\x20object:\x20{\x20identifier:\x200\x20},\x20parameters:\x20[identifier[1]]),\x20...)'},'constraints':['EntityRegistrar\x20address\x20is\x20fixed\x20at\x200xaab\x20(system\x20address)','EntityLinker\x20address\x20is\x20fixed\x20at\x200xaaa','table[0]\x20has\x20is_system_address=true','query\x20parameters\x20must\x20match\x20the\x20instruction\x20definition'],'example':{'root':{'type':'logic_and','nodes':[{'type':'query','query':'entity.registrar.records','object':{'identifier':0x0},'parameters':[{'type':'identifier','identifier':0x1}]}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'0xaab','name':'EntityRegistrar\x20system\x20address'},{'identifier':0x1,'b_submission':!![],'value_type':'Address','name':'User\x20address\x20(submitted)'}]}},{'id':'P12','pattern_name':'Dynamic\x20voting\x20weight','data_source_combination':'Type3\x20+\x20Type4\x20+\x20Type1\x20constant','semantic_intent':'Voting\x20weight\x20equals\x20the\x20reputation\x20score\x20(extracted\x20from\x20submitted\x20data)','match_keywords':['weight','vote','reputation','score','voting','weight'],'schema_elements':{'root_type':'logic_and','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Voter\x20address\x20(Type3)'},{'value_type':'U64','b_submission':!![],'purpose':'Voter\x20weight\x20(Type3,\x20extracted\x20by\x20GuardIdentifier)'}],'context_nodes':[{'context_type':'Signer','purpose':'Validate\x20voter\x20identity\x20(Type4)'}],'query_nodes':[{'query_name':'entity.registrar.records','object_type':'EntityRegistrar'}],'tree_structure':'logic_and(identity\x20check:\x20logic_equal(context(Signer),\x20identifier[0]),\x20weight\x20comparison:\x20GuardIdentifier\x20extracts\x20identifier[1])'},'constraints':['The\x20table\x20entry\x20referenced\x20by\x20GuardIdentifier\x20must\x20be\x20numeric\x20(U8-U256)','b_submission\x20must\x20be\x20true\x20(weight\x20is\x20submitted\x20at\x20runtime\x20by\x20the\x20voter)','Non-numeric\x20types\x20cause\x20E_GUARD_IDENTIFIER_NOT_NUMBER\x20error','Weight\x20value\x20is\x20cast\x20to\x20u32','voting_guard\x20scene\x20special\x20constraint:\x20GuardIdentifier\x20numeric'],'example':{'root':{'type':'logic_and','nodes':[{},{}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'Voter\x20address'},{'identifier':0x1,'b_submission':!![],'value_type':'U64','name':'Voter\x20weight\x20(extracted\x20from\x20reputation\x20score)'}]}},{'id':'P13','pattern_name':'Repository\x20data\x20query','data_source_combination':'Type1\x20+\x20Type2','semantic_intent':'Query\x20Repository\x20data\x20and\x20validate','match_keywords':['Repository','storage','data\x20source','weather','external\x20data','oracle'],'schema_elements':{'root_type':'logic_and','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'Repository\x20address\x20(Type1\x20constant)'}],'query_nodes':[{'query_name':'repository.data','object_type':'Repository'}],'tree_structure':'logic_and(query(1167:\x20repository.data,\x20object:\x20{\x20identifier:\x200\x20},\x20parameters:\x20[...]),\x20[data\x20validation\x20condition])'},'constraints':['quote_guard\x20is\x20a\x20RIGID\x20verification\x20requirement:\x20any\x20guard\x20querying\x20Repository\x20data\x20with\x20quote_guard\x20must\x20satisfy\x20it','Two-phase:\x20passport\x20generation\x20scans/prepares\x20quote_guard,\x20passport\x20verification\x20re-checks\x20+\x20verifies\x20(see\x20R-X1-10)','If\x20quote_guard==None:\x20no\x20access\x20control\x20—\x20Repository\x20data\x20is\x20freely\x20queryable','rep\x20semantics:\x20repository.data\x20query\x20does\x20not\x20depend\x20on\x20runtime\x20submission,\x20so\x20rep=true'],'example':{'root':{'type':'logic_and','nodes':[{'type':'query','query':'repository.data','object':{'identifier':0x0},'parameters':[{'type':'identifier','identifier':0x1}]},{}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'0xREPO','name':'Repository\x20address'}]}},{'id':'P14','pattern_name':'Pure\x20dependency\x20combination','data_source_combination':'None\x20(rely\x20only)','semantic_intent':'Does\x20not\x20compute\x20itself;\x20fully\x20depends\x20on\x20the\x20results\x20of\x20other\x20Guards','match_keywords':['depend','combine','reuse','rely','delegate'],'schema_elements':{'root_type':'logic_and\x20/\x20logic_or\x20(minimized\x20tautology)','table_entries':[],'tree_structure':'root:\x20minimized\x20(e.g.\x20context(Clock)\x20>=\x200,\x20tautology)\x20+\x20rely:\x20{\x20guards:\x20[...],\x20logic_or:\x20false\x20}'},'constraints':['Depended-on\x20Guards\x20must\x20have\x20rep=true\x20(repository.data\x20query\x20does\x20not\x20depend\x20on\x20runtime\x20submission)','rely.guards\x20supports\x20at\x20most\x204\x20(MAX_DEPENDED_COUNT)','Self-reference\x20is\x20forbidden','AND\x20logic:\x20all\x20dependencies\x20must\x20pass;\x20OR\x20logic:\x20any\x20one\x20passing\x20is\x20sufficient'],'example':{'root':{'type':'logic_as_u256_greater_or_equal','nodes':[{'type':'context','context':'Clock'},{'type':'identifier','identifier':0x0}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'U64','value':0x0,'name':'Tautology\x20baseline\x20value\x20(0)'}],'rely':{'guards':['guard_a','guard_b'],'logic_or':![]}}},{'id':'P15','pattern_name':'Submission\x20data\x20retention\x20pattern\x20(retained_submission)','data_source_combination':'Type3\x20+\x20Type4\x20(submission\x20+\x20system\x20context\x20binding)','semantic_intent':'Guard\x20accepts\x20runtime-submitted\x20data\x20but\x20ensures\x20it\x20is\x20trustworthy\x20via\x20Signer\x20binding\x20and\x20type\x20checking','match_keywords':['submit','retain','retained','submission','bind\x20signer','submission\x20check'],'schema_elements':{'root_type':'logic_and','table_entries':[{'value_type':'Address','b_submission':!![],'purpose':'Submitted\x20object\x20address\x20(Type3,\x20requires\x20Signer\x20binding)'},{'value_type':'U256','b_submission':!![],'purpose':'Submitted\x20numeric\x20value\x20(e.g.\x20amount,\x20weight,\x20requires\x20range\x20check)'}],'context_nodes':[{'context_type':'Signer','purpose':'Validate\x20submitter\x20identity\x20to\x20ensure\x20submission\x20data\x20ownership'}],'tree_structure':'logic_and(logic_equal(context(Signer),\x20query(...,\x20signer_field)),\x20logic_as_u256_greater_or_equal(identifier[1],\x20identifier[2]))'},'constraints':['The\x20name\x20of\x20each\x20b_submission=true\x20entry\x20must\x20be\x20a\x20complete\x20natural-language\x20description\x20(not\x20a\x20technical\x20identifier)','The\x20submitted\x20object\x20address\x20should\x20be\x20bound\x20to\x20Signer\x20(query\x20the\x20signer/owner\x20field\x20of\x20the\x20submitted\x20object\x20to\x20validate\x20ownership)','Submitted\x20numeric\x20values\x20should\x20have\x20range\x20checks\x20(>=\x20min,\x20<=\x20max)','Total\x20table\x20size\x20must\x20not\x20exceed\x2040000\x20bytes','Total\x20submission\x20bytes\x20must\x20not\x20exceed\x20'+MAX_SUBMISSION_SIZE_PASSPORT],'example':{'root':{'type':'logic_and','nodes':[{'type':'logic_equal','nodes':[{'type':'context','context':'Signer'},{'type':'query','query':0x4d5,'object':{'identifier':0x0},'parameters':[]}]},{'type':'logic_as_u256_greater_or_equal','nodes':[{'type':'identifier','identifier':0x1},{'type':'identifier','identifier':0x2}]}]},'table':[{'identifier':0x0,'b_submission':!![],'value_type':'Address','name':'Submitted\x20Order\x20object\x20address;\x20must\x20belong\x20to\x20the\x20current\x20signer'},{'identifier':0x1,'b_submission':!![],'value_type':'U256','name':'Submitted\x20amount\x20(unit:\x20MIST);\x20must\x20be\x20>=\x20minimum\x20amount'},{'identifier':0x2,'b_submission':![],'value_type':'U256','value':0xf4240,'name':'Minimum\x20amount\x20constant\x20(1\x20MIST)'}]}},{'id':'P16','pattern_name':'Circular\x20reference\x20pattern\x20(Guard\x20references\x20the\x20host\x20object\x20itself)','data_source_combination':'Type1\x20(host\x20object\x20as\x20constant,\x20using\x20name\x20instead\x20of\x20address)','semantic_intent':'Guard\x20binds\x20to\x20a\x20Host\x20Object\x20while\x20querying\x20the\x20Host\x20Object\x27s\x20own\x20fields;\x20uses\x20name\x20reference\x20to\x20achieve\x20circular\x20binding','match_keywords':['circular\x20reference','self','host','host','circular','self-reference'],'schema_elements':{'root_type':'logic_equal\x20/\x20logic_and','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'Host\x20object\x20name\x20(SDK\x20resolves\x20to\x20address\x20at\x20binding\x20time)'}],'query_nodes':[{'query_name':'query_service_*\x20/\x20query_machine_*','object_type':'Service\x20/\x20Machine'}],'tree_structure':'logic_equal(query(<host_field_query>,\x20object:\x20{\x20identifier:\x200\x20}),\x20identifier[1]\x20or\x20context(Signer))'},'constraints':['The\x20Host\x20Object\x20must\x20not\x20be\x20published\x20(bPublished=false)\x20when\x20creating\x20and\x20binding\x20the\x20Guard','Use\x20the\x20Host\x20Object\x20name\x20(not\x20address)\x20in\x20the\x20table;\x20the\x20SDK\x20resolves\x20it\x20at\x20binding\x20time','The\x20Host\x20Object\x20can\x20only\x20be\x20published\x20after\x20the\x20Guard\x20is\x20bound','Guard\x20verification\x20only\x20runs\x20normally\x20after\x20the\x20Host\x20Object\x20is\x20published','Use\x20guard2file\x20to\x20export\x20Guard\x20backups\x20for\x20easy\x20rebuilding'],'example':{'root':{'type':'logic_equal','nodes':[{'type':'query','query':0x4cf,'object':{'identifier':0x0},'parameters':[]},{'type':'identifier','identifier':0x1}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'my_service','name':'Host\x20Service\x20name\x20(circular\x20reference,\x20resolved\x20by\x20SDK\x20at\x20binding\x20time)'},{'identifier':0x1,'b_submission':![],'value_type':'Bool','value':![],'name':'Expected\x20Service\x20paused\x20state\x20(false=not\x20paused)'}]}},{'id':'P17','pattern_name':'Query\x20parameter\x20translation\x20pattern\x20(type\x20conversion\x20node\x20combination)','data_source_combination':'Type1/2\x20+\x20type\x20conversion\x20(query\x20parameter\x20type\x20translation)','semantic_intent':'Guard\x20queries\x20parameters\x20that\x20require\x20type\x20conversion\x20(e.g.\x20Address\x20→\x20U64\x20timestamp\x20key);\x20uses\x20convert_*\x20nodes\x20to\x20translate','match_keywords':['type\x20conversion','translate','convert','timestamp\x20key','parameter\x20translation','address\x20to\x20u64'],'schema_elements':{'root_type':'logic_equal\x20/\x20logic_as_u256_greater_or_equal','table_entries':[{'value_type':'Address','b_submission':![],'purpose':'Query\x20target\x20object\x20address\x20(Type1/2)'},{'value_type':'U64','b_submission':![],'purpose':'Comparison\x20baseline\x20value\x20(e.g.\x20timestamp\x20threshold)'}],'query_nodes':[{'query_name':'query_repository_data\x20/\x20query_progress_history_*','object_type':'Repository\x20/\x20Progress'}],'tree_structure':'logic_as_u256_greater_or_equal(query(<query_with_converted_param>,\x20object:\x20{\x20identifier:\x200\x20},\x20parameters:\x20[convert_number_address(identifier[1])]),\x20identifier[2])'},'constraints':['The\x20query\x20parameter\x20type\x20must\x20match\x20the\x20parameters\x20type\x20defined\x20in\x20GUARDQUERY','If\x20the\x20table\x20declares\x20Address\x20but\x20the\x20query\x20requires\x20U64,\x20convert_number_address\x20must\x20be\x20used\x20to\x20translate','The\x20input\x20type\x20of\x20convert_*\x20nodes\x20must\x20be\x20compatible\x20with\x20the\x20child\x20node\x27s\x20return\x20type','The\x20translated\x20type\x20must\x20match\x20the\x20parameters\x20definition\x20of\x20the\x20query\x20instruction','Use\x20wowok_buildin_info\x20info=\x27guard\x20instructions\x27\x20to\x20verify\x20parameter\x20types'],'example':{'root':{'type':'logic_as_u256_greater_or_equal','nodes':[{'type':'query','query':0x48f,'object':{'identifier':0x0},'parameters':[{'type':'convert_number_address','nodes':[{'type':'identifier','identifier':0x1}]}]},{'type':'identifier','identifier':0x2}]},'table':[{'identifier':0x0,'b_submission':![],'value_type':'Address','value':'0xrepo','name':'Repository\x20address\x20constant'},{'identifier':0x1,'b_submission':![],'value_type':'U64','value':0x18bcfe56800,'name':'Timestamp\x20key\x20(U64,\x20needs\x20to\x20be\x20converted\x20to\x20Address\x20for\x20Repository\x20query)'},{'identifier':0x2,'b_submission':![],'value_type':'U256','value':0x64,'name':'Expected\x20Repository\x20data\x20value'}]}}];export const SCHEMA_TO_SEMANTIC_RULES=[{'element_type':'node','type_name':'logic_equal','semantic':'Equality\x20comparison\x20(==),\x20returns\x20Bool.\x20Accepts\x20any\x20type\x20but\x20both\x20operands\x20must\x20be\x20type-compatible','return_type':'Bool','child_constraints':'2\x20child\x20nodes,\x20types\x20must\x20be\x20compatible'},{'element_type':'node','type_name':'logic_not','semantic':'Logical\x20NOT\x20(!),\x20returns\x20Bool','return_type':'Bool','child_constraints':'1\x20child\x20node,\x20must\x20be\x20Bool'},{'element_type':'node','type_name':'logic_and','semantic':'Logical\x20AND;\x20true\x20if\x20all\x20child\x20nodes\x20are\x20true','return_type':'Bool','child_constraints':'2-8\x20Bool\x20child\x20nodes\x20(MAX_MULTI_OPERANDS)'},{'element_type':'node','type_name':'logic_or','semantic':'Logical\x20OR;\x20true\x20if\x20any\x20child\x20node\x20is\x20true','return_type':'Bool','child_constraints':'2-8\x20Bool\x20child\x20nodes'},{'element_type':'node','type_name':'logic_as_u256_greater','semantic':'Numeric\x20greater\x20than\x20(>),\x20auto-widened\x20to\x20U256','return_type':'Bool','child_constraints':'2\x20numeric\x20child\x20nodes\x20(U8-U256\x20compatible)'},{'element_type':'node','type_name':'logic_as_u256_lesser','semantic':'Numeric\x20less\x20than\x20(<)','return_type':'Bool','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'logic_as_u256_equal','semantic':'Numeric\x20equality\x20(==)','return_type':'Bool','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'logic_as_u256_greater_or_equal','semantic':'Numeric\x20greater\x20than\x20or\x20equal\x20(>=)','return_type':'Bool','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'logic_as_u256_lesser_or_equal','semantic':'Numeric\x20less\x20than\x20or\x20equal\x20(<=)','return_type':'Bool','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'logic_string_contains','semantic':'String\x20contains\x20(case-sensitive)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'logic_string_nocase_contains','semantic':'String\x20contains\x20(case-insensitive)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'logic_string_nocase_equal','semantic':'String\x20equality\x20(case-insensitive)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'identifier','semantic':'References\x20the\x20value\x20of\x20a\x20table\x20entry.\x20The\x20data\x20source\x20type\x20depends\x20on\x20b_submission:\x20false=Type1\x20constant,\x20true=Type3\x20submitted','return_type':'Determined\x20by\x20table\x20entry\x20value_type','child_constraints':'No\x20child\x20nodes;\x20requires\x20identifier\x20field\x20to\x20reference\x20table','data_source_class':'Type1_OnChainConstant'},{'element_type':'node','type_name':'context','semantic':'Transaction\x20context\x20data\x20(Type4\x20SystemContext).\x20Signer=signer\x20address,\x20Clock=on-chain\x20timestamp\x20(U64),\x20Guard=ObjectID\x20of\x20the\x20Guard\x20currently\x20being\x20verified','return_type':'Address\x20(Signer/Guard)\x20/\x20U64\x20(Clock)','child_constraints':'No\x20child\x20nodes','data_source_class':'Type4_SystemContext'},{'element_type':'node','type_name':'query','semantic':'Queries\x20on-chain\x20object\x20data.\x20The\x20data\x20source\x20type\x20depends\x20on\x20object.convert_witness:\x20present=Type2\x20(witness-derived),\x20absent+constant=Type1,\x20absent+submitted=Type3','return_type':'Determined\x20by\x20the\x20query\x20instruction','child_constraints':'Requires\x20query\x20+\x20object\x20+\x20parameters\x20fields','data_source_class':'Type1_OnChainConstant','discovery_tool':'wowok_buildin_info(info=\x27guard\x20instructions\x27)'},{'element_type':'node','type_name':'calc_number_add','semantic':'Numeric\x20addition','return_type':'U256','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'calc_number_subtract','semantic':'Numeric\x20subtraction','return_type':'U256','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'calc_number_multiply','semantic':'Numeric\x20multiplication','return_type':'U256','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'calc_number_divide','semantic':'Numeric\x20division','return_type':'U256','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'calc_number_mod','semantic':'Numeric\x20modulo','return_type':'U256','child_constraints':'2\x20numeric\x20child\x20nodes'},{'element_type':'node','type_name':'calc_string_length','semantic':'String\x20length','return_type':'U64','child_constraints':'1\x20String\x20child\x20node'},{'element_type':'node','type_name':'calc_string_contains','semantic':'String\x20contains\x20(returns\x20Bool)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'calc_string_nocase_contains','semantic':'String\x20contains\x20(case-insensitive,\x20returns\x20Bool)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'calc_string_nocase_equal','semantic':'String\x20equality\x20(case-insensitive,\x20returns\x20Bool)','return_type':'Bool','child_constraints':'2\x20String\x20child\x20nodes'},{'element_type':'node','type_name':'calc_string_indexof','semantic':'String\x20find\x20index','return_type':'U64','child_constraints':'2\x20String\x20child\x20nodes\x20+\x20order'},{'element_type':'node','type_name':'calc_string_nocase_indexof','semantic':'String\x20find\x20index\x20(case-insensitive)','return_type':'U64','child_constraints':'2\x20String\x20child\x20nodes\x20+\x20order'},{'element_type':'node','type_name':'convert_number_address','semantic':'Number\x20→\x20Address\x20conversion\x20(e.g.\x20timestamp\x20to\x20address)','return_type':'Address','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_address_number','semantic':'Address\x20→\x20Number\x20conversion','return_type':'U256','child_constraints':'1\x20Address\x20child\x20node'},{'element_type':'node','type_name':'convert_number_string','semantic':'Number\x20→\x20String\x20conversion','return_type':'String','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_string_number','semantic':'String\x20→\x20Number\x20conversion','return_type':'U256','child_constraints':'1\x20String\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u8','semantic':'Safe\x20conversion\x20to\x20U8\x20(errors\x20on\x20overflow)','return_type':'U8','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u16','semantic':'Safe\x20conversion\x20to\x20U16','return_type':'U16','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u32','semantic':'Safe\x20conversion\x20to\x20U32','return_type':'U32','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u64','semantic':'Safe\x20conversion\x20to\x20U64','return_type':'U64','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u128','semantic':'Safe\x20conversion\x20to\x20U128','return_type':'U128','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'convert_safe_u256','semantic':'Safe\x20conversion\x20to\x20U256','return_type':'U256','child_constraints':'1\x20numeric\x20child\x20node'},{'element_type':'node','type_name':'value_type','semantic':'Returns\x20the\x20value\x27s\x20type\x20identifier\x20(U8)\x20—\x20used\x20for\x20dynamic\x20type\x20checking','return_type':'U8','child_constraints':'1\x20variable\x20child\x20node'},{'element_type':'node','type_name':'vec_length','semantic':'Vector\x20length','return_type':'U64','child_constraints':'1\x20vec\x20child\x20node'},{'element_type':'node','type_name':'vec_contains_bool','semantic':'Whether\x20the\x20vector\x20contains\x20a\x20Bool\x20value','return_type':'Bool','child_constraints':'1\x20VecBool\x20+\x201\x20Bool'},{'element_type':'node','type_name':'vec_contains_address','semantic':'Whether\x20the\x20vector\x20contains\x20an\x20Address\x20(whitelist\x20check)','return_type':'Bool','child_constraints':'1\x20VecAddress\x20+\x201\x20Address'},{'element_type':'node','type_name':'vec_contains_string','semantic':'Whether\x20the\x20vector\x20contains\x20a\x20String','return_type':'Bool','child_constraints':'1\x20VecString\x20+\x201\x20String'},{'element_type':'node','type_name':'vec_contains_string_nocase','semantic':'Whether\x20the\x20vector\x20contains\x20a\x20String\x20(case-insensitive)','return_type':'Bool','child_constraints':'1\x20VecString\x20+\x201\x20String'},{'element_type':'node','type_name':'vec_contains_number','semantic':'Whether\x20the\x20vector\x20contains\x20a\x20number','return_type':'Bool','child_constraints':'1\x20Vec*\x20+\x201\x20Number'},{'element_type':'node','type_name':'vec_indexof_bool','semantic':'Bool\x20vector\x20find\x20index','return_type':'U64','child_constraints':'VecBool\x20+\x20Bool\x20+\x20order'},{'element_type':'node','type_name':'vec_indexof_address','semantic':'Address\x20vector\x20find\x20index','return_type':'U64','child_constraints':'VecAddress\x20+\x20Address\x20+\x20order'},{'element_type':'node','type_name':'vec_indexof_string','semantic':'String\x20vector\x20find\x20index','return_type':'U64','child_constraints':'VecString\x20+\x20String\x20+\x20order'},{'element_type':'node','type_name':'vec_indexof_string_nocase','semantic':'String\x20vector\x20find\x20index\x20(case-insensitive)','return_type':'U64','child_constraints':'VecString\x20+\x20String\x20+\x20order'},{'element_type':'node','type_name':'vec_indexof_number','semantic':'Numeric\x20vector\x20find\x20index','return_type':'U64','child_constraints':'Vec*\x20+\x20Number\x20+\x20order'},{'element_type':'node','type_name':'query_reward_record_find','semantic':'Query\x20reward\x20claim\x20records\x20(returns\x20the\x20found\x20record)','return_type':'Bool','child_constraints':'Requires\x20object\x20+\x20recipient\x20+\x20where\x20+\x20find'},{'element_type':'node','type_name':'query_reward_record_count','semantic':'Query\x20reward\x20claim\x20record\x20count\x20(U64)','return_type':'U64','child_constraints':'Requires\x20object\x20+\x20recipient\x20(optional)'},{'element_type':'node','type_name':'query_reward_record_exists','semantic':'Query\x20whether\x20a\x20reward\x20claim\x20record\x20exists\x20(Bool)','return_type':'Bool','child_constraints':'Requires\x20object\x20+\x20recipient\x20(optional)'},{'element_type':'node','type_name':'query_progress_history_find','semantic':'Query\x20whether\x20a\x20specified\x20session\x20exists\x20in\x20Progress\x20history','return_type':'Bool','child_constraints':'Requires\x20object\x20+\x20where\x20+\x20find'},{'element_type':'node','type_name':'query_progress_history_session_find','semantic':'Query\x20a\x20Progress\x20session','return_type':'Bool','child_constraints':'Requires\x20object\x20+\x20historyIdx\x20+\x20where\x20+\x20find'},{'element_type':'node','type_name':'query_progress_history_session_forward_find','semantic':'Query\x20whether\x20a\x20specified\x20forward\x20exists\x20in\x20a\x20Progress\x20session','return_type':'Bool','child_constraints':'Requires\x20object\x20+\x20historyIdx\x20+\x20sessionIdx\x20+\x20where\x20+\x20find'},{'element_type':'node','type_name':'query_progress_history_session_count','semantic':'Query\x20the\x20number\x20of\x20Progress\x20sessions','return_type':'U64','child_constraints':'Requires\x20object\x20+\x20historyIdx'},{'element_type':'node','type_name':'query_progress_history_session_forward_count','semantic':'Query\x20the\x20number\x20of\x20forwards\x20in\x20a\x20Progress\x20session','return_type':'U64','child_constraints':'Requires\x20object\x20+\x20historyIdx\x20+\x20sessionIdx'},{'element_type':'node','type_name':'query_progress_history_session_forward_retained_submission_count','semantic':'Query\x20the\x20retained\x20submission\x20count\x20of\x20a\x20forward\x20in\x20a\x20Progress\x20session','return_type':'U64','child_constraints':'Requires\x20object\x20+\x20historyIdx\x20+\x20sessionIdx\x20+\x20forwardIdx'},{'element_type':'witness','type_name':'TypeOrderProgress','semantic':'Reads\x20the\x20order.progress\x20field\x20from\x20an\x20Order\x20address\x20to\x20derive\x20Progress\x20(100,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived','discovery_tool':'wowok_buildin_info(info=\x27guard\x20instructions\x27)'},{'element_type':'witness','type_name':'TypeOrderMachine','semantic':'Reads\x20the\x20order.machine\x20field\x20from\x20an\x20Order\x20address\x20to\x20derive\x20Machine\x20(101,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeOrderService','semantic':'Reads\x20the\x20order.service\x20field\x20from\x20an\x20Order\x20address\x20to\x20derive\x20Service\x20(102,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeProgressMachine','semantic':'Reads\x20the\x20progress.machine\x20field\x20from\x20a\x20Progress\x20address\x20to\x20derive\x20Machine\x20(103,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeArbOrder','semantic':'Reads\x20the\x20arb.order\x20field\x20from\x20an\x20Arb\x20address\x20to\x20derive\x20Order\x20(104,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeArbArbitration','semantic':'Reads\x20the\x20arb.arbitration\x20field\x20from\x20an\x20Arb\x20address\x20to\x20derive\x20the\x20parent\x20Arbitration\x20service\x20(105,\x20single\x20hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeArbProgress','semantic':'Derives\x20from\x20Arb\x20in\x20two\x20hops:\x20arb.order\x20→\x20order.progress\x20(106,\x20multi-hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeArbMachine','semantic':'Derives\x20from\x20Arb\x20in\x20two\x20hops:\x20arb.order\x20→\x20order.machine\x20(107,\x20multi-hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'witness','type_name':'TypeArbService','semantic':'Derives\x20from\x20Arb\x20in\x20two\x20hops:\x20arb.order\x20→\x20order.service\x20(108,\x20multi-hop)','data_source_class':'Type2_WitnessDerived'},{'element_type':'context','type_name':'Signer','semantic':'Current\x20transaction\x20signer\x20address\x20(TransactionContext.sender())','return_type':'Address','data_source_class':'Type4_SystemContext'},{'element_type':'context','type_name':'Clock','semantic':'Current\x20on-chain\x20timestamp\x20(reads\x20timestamp_ms\x20of\x20WOW_CLOCK_OBJECT_ID\x200x6)','return_type':'U64','data_source_class':'Type4_SystemContext'},{'element_type':'context','type_name':'Guard','semantic':'ObjectID\x20of\x20the\x20Guard\x20object\x20currently\x20being\x20verified\x20(self-reference,\x20rare)','return_type':'Address','data_source_class':'Type4_SystemContext'},{'element_type':'table_entry','type_name':'Bool','semantic':'Boolean\x20constant\x20or\x20submission'},{'element_type':'table_entry','type_name':'Address','semantic':'Address\x20constant\x20(Type1)\x20or\x20submission\x20(Type3).\x20Object\x20address\x20type'},{'element_type':'table_entry','type_name':'String','semantic':'String\x20constant\x20or\x20submission'},{'element_type':'table_entry','type_name':'U8','semantic':'8-bit\x20unsigned\x20integer'},{'element_type':'table_entry','type_name':'U16','semantic':'16-bit\x20unsigned\x20integer'},{'element_type':'table_entry','type_name':'U32','semantic':'32-bit\x20unsigned\x20integer'},{'element_type':'table_entry','type_name':'U64','semantic':'64-bit\x20unsigned\x20integer\x20(commonly\x20used\x20for\x20timestamps)'},{'element_type':'table_entry','type_name':'U128','semantic':'128-bit\x20unsigned\x20integer'},{'element_type':'table_entry','type_name':'U256','semantic':'256-bit\x20unsigned\x20integer\x20(auto-widening\x20target\x20for\x20numeric\x20operations)'},{'element_type':'table_entry','type_name':'VecAddress','semantic':'Address\x20vector\x20(used\x20for\x20whitelists,\x20Type1\x20constant)'},{'element_type':'table_entry','type_name':'VecString','semantic':'String\x20vector'},{'element_type':'table_entry','type_name':'VecU64','semantic':'U64\x20vector'},{'element_type':'table_entry','type_name':'VecU8','semantic':'U8\x20vector\x20(raw\x20bytes)'},{'element_type':'table_entry','type_name':'Value','semantic':'Dynamic\x20type\x20(19,\x20first\x20byte\x20is\x20the\x20type\x20identifier)\x20—\x20used\x20for\x20Repository\x20data,\x20EntityRegistrar\x20records,\x20Passport\x20submission\x20value'},{'element_type':'rely','type_name':'rely_and','semantic':'Depends\x20on\x20other\x20Guards,\x20AND\x20logic\x20(all\x20must\x20pass).\x20Depended-on\x20Guards\x20must\x20have\x20rep=true','child_constraints':'At\x20most\x204\x20dependencies,\x20each\x20with\x20rep=true\x20(repository.data\x20query\x20does\x20not\x20depend\x20on\x20submission)'},{'element_type':'rely','type_name':'rely_or','semantic':'Depends\x20on\x20other\x20Guards,\x20OR\x20logic\x20(any\x20one\x20passing\x20is\x20sufficient).\x20Depended-on\x20Guards\x20must\x20have\x20rep=true','child_constraints':'At\x20most\x204\x20dependencies,\x20each\x20with\x20rep=true'}];export const GUARD_CONSTRAINT_RULES=[{'id':'ROOT_01','name':'root\x20returns\x20Bool','description':'The\x20Guard\x20root\x20node\x20must\x20return\x20a\x20Bool\x20type','category':'root','phase':'creation','validation_logic':'root.node_type\x20must\x20be\x20in\x20the\x20allowedTypes\x20list\x20(logic_*,\x20calc_string_contains,\x20vec_contains_*,\x20query_reward_record_exists,\x20query[Bool\x20return],\x20identifier[Bool\x20type])','failure_message':'Guard\x20root\x20node\x20must\x20be\x20an\x20operation\x20that\x20returns\x20Bool','verification_location':'SDK\x20buildNode(root,\x20ValueType.Bool,\x20...)','pitfall_number':0x7},{'id':'TABLE_01','name':'identifier\x20uniqueness','description':'Each\x20identifier\x20in\x20the\x20table\x20must\x20be\x20unique\x20(0-255)','category':'table','phase':'creation','validation_logic':'No\x20duplicate\x20identifiers\x20in\x20the\x20table','failure_message':'Duplicate\x20table\x20identifier','verification_location':'SDK\x20lodash\x20groupBy'},{'id':'TABLE_02','name':'identifier\x20referential\x20integrity','description':'Every\x20identifier\x20node\x20in\x20the\x20computation\x20tree\x20must\x20exist\x20in\x20the\x20table','category':'table','phase':'creation','validation_logic':'Traverse\x20the\x20computation\x20tree;\x20each\x20identifier\x20node\x27s\x20index\x20exists\x20in\x20the\x20table','failure_message':'Identifier\x20not\x20found\x20in\x20table','verification_location':'SDK\x20buildNode','pitfall_number':0x1},{'id':'TABLE_03','name':'Constant\x20entries\x20must\x20have\x20a\x20value','description':'Entries\x20with\x20b_submission=false\x20must\x20have\x20a\x20value\x20field','category':'table','phase':'creation','validation_logic':'All\x20entries\x20with\x20b_submission=false\x20have\x20a\x20non-empty\x20value\x20field','failure_message':'Constant\x20table\x20entry\x20must\x20have\x20a\x20value','verification_location':'SDK\x20operate'},{'id':'TABLE_04','name':'table\x20size\x20limit','description':'At\x20most\x20256\x20entries;\x20serialized\x20size\x20must\x20not\x20exceed\x2040000\x20bytes','category':'table','phase':'creation','validation_logic':'table.length\x20<=\x20256\x20&&\x20serialize(table).length\x20<=\x2040000','failure_message':'Table\x20exceeds\x20size\x20limit\x20(256\x20entries\x20or\x2040000\x20bytes)','verification_location':'Move\x20guard::new'},{'id':'TABLE_05','name':'submission\x20entry\x20value\x20is\x201\x20byte\x20(type\x20code\x20only)','description':'Entries\x20with\x20b_submission=true\x20have\x20a\x20serialized\x20value\x20of\x20just\x201\x20byte\x20(the\x20type\x20code)','category':'table','phase':'creation','validation_logic':'When\x20b_submission=true,\x20bcsValue.length\x20===\x201\x20and\x20bcsValue[0]\x20===\x20valueType','failure_message':'Submission\x20table\x20entry\x20value\x20must\x20be\x201\x20byte\x20(type\x20code\x20only)','verification_location':'native\x20deserialize_constants'},{'id':'QUERY_01','name':'query\x20instruction\x20valid','description':'The\x20query\x20field\x20of\x20a\x20query\x20node\x20must\x20be\x20a\x20valid\x20GUARDQUERY\x20ID\x20or\x20name','category':'query','phase':'creation','validation_logic':'The\x20query\x20field\x20exists\x20in\x20GUARDQUERY\x20(via\x20isValidGuardQueryIdOrName)','failure_message':'Invalid\x20Guard\x20query\x20instruction','verification_location':'SDK\x20getGuardQueryInfo','pitfall_number':0x3},{'id':'QUERY_02','name':'query\x20parameter\x20count\x20match','description':'The\x20number\x20and\x20types\x20of\x20parameters\x20in\x20a\x20query\x20node\x20must\x20match\x20the\x20instruction\x20definition','category':'query','phase':'creation','validation_logic':'parameters.length\x20===\x20instruction.parameters.length\x20&&\x20type-compatible','failure_message':'Query\x20parameter\x20count\x20or\x20type\x20mismatch','verification_location':'SDK\x20buildNode','pitfall_number':0x3},{'id':'QUERY_03','name':'query\x20return\x20type\x20compatible','description':'The\x20return\x20type\x20of\x20a\x20query\x20node\x20must\x20be\x20compatible\x20with\x20the\x20parent\x20node\x27s\x20expected\x20type','category':'query','phase':'creation','validation_logic':'checkType(query.return_type,\x20parent.expected_type)','failure_message':'Query\x20return\x20type\x20incompatible\x20with\x20parent\x20node','verification_location':'SDK\x20checkType'},{'id':'QUERY_04','name':'query\x20object\x20identifier\x27s\x20value_type\x20is\x20Address','description':'The\x20table\x20entry\x20referenced\x20by\x20query\x20node\x27s\x20object.identifier\x20must\x20have\x20value_type\x20of\x20Address','category':'query','phase':'creation','validation_logic':'table[object.identifier].value_type\x20===\x20Address','failure_message':'Query\x20object\x20identifier\x20must\x20reference\x20an\x20Address-type\x20table\x20entry','verification_location':'SDK\x20buildNode\x20L603-609'},{'id':'WITNESS_01','name':'witness\x20type\x20valid','description':'convert_witness\x20must\x20be\x20a\x20valid\x20WitnessType\x20(100-108)','category':'witness','phase':'creation','validation_logic':'The\x20witness\x20value\x20is\x20within\x20the\x20range\x20allowed\x20by\x20WitnessTypeSchema\x20(100-108)','failure_message':'Invalid\x20witness\x20type','verification_location':'SDK\x20isWitnessType','pitfall_number':0x4},{'id':'WITNESS_02','name':'witness\x20target\x20matches\x20query\x20objectType','description':'The\x20witness\x27s\x20target\x20type\x20must\x20match\x20the\x20query\x20instruction\x27s\x20objectType','category':'witness','phase':'creation','validation_logic':'witness.target_type\x20===\x20instruction.objectType','failure_message':'Witness\x20target\x20type\x20does\x20not\x20match\x20query\x20object\x20type','verification_location':'SDK\x20buildNode\x20L613-619','pitfall_number':0x4},{'id':'WITNESS_03','name':'witness\x20source\x20matches\x20tableItem\x20object_type','description':'The\x20witness\x27s\x20source\x20type\x20must\x20match\x20the\x20object_type\x20declared\x20in\x20the\x20table\x20entry\x20(if\x20declared)','category':'witness','phase':'creation','validation_logic':'table[identifier].object_type\x20===\x20witness.source_type\x20(if\x20tableItem.object_type\x20is\x20declared)','failure_message':'Witness\x20source\x20type\x20does\x20not\x20match\x20table\x20entry\x20object_type','verification_location':'SDK\x20buildNode\x20L622-631','pitfall_number':0x4},{'id':'RELY_01','name':'rely\x20dependency\x20count\x20≤\x204','description':'rely.guards\x20supports\x20at\x20most\x204\x20dependencies\x20(MAX_DEPENDED_COUNT)','category':'rely','phase':'creation','validation_logic':'rely.guards.length\x20<=\x204','failure_message':'Rely\x20dependencies\x20exceed\x20limit\x20(4)','verification_location':'SDK\x20reliesAdd'},{'id':'RELY_02','name':'rely\x20dependency\x20rep=true','description':'All\x20rely-depended\x20Guards\x20must\x20have\x20rep=true\x20(repository.data\x20query\x20does\x20not\x20depend\x20on\x20runtime\x20submission)','category':'rely','phase':'creation','validation_logic':'Query\x20each\x20depended\x20Guard\x27s\x20rep\x20field;\x20must\x20be\x20true','failure_message':'Rely\x20dependency\x20has\x20rep=false\x20(not\x20standalone)','verification_location':'Move\x20guard::relies_add','pitfall_number':0x8},{'id':'RELY_03','name':'rely\x20forbids\x20self-reference','description':'A\x20Guard\x20cannot\x20depend\x20on\x20itself','category':'rely','phase':'creation','validation_logic':'rely.guards\x20does\x20not\x20contain\x20the\x20current\x20Guard\x27s\x20address','failure_message':'Guard\x20cannot\x20rely\x20on\x20itself','verification_location':'SDK\x20reliesAdd'},{'id':'BINDING_01','name':'voting_guard\x20GuardIdentifier\x20numeric','description':'The\x20table\x20entry\x20referenced\x20by\x20Arbitration\x20voting_guard\x27s\x20GuardIdentifier\x20must\x20be\x20of\x20a\x20numeric\x20type','category':'binding','phase':'creation','validation_logic':'If\x20binding=voting_guard,\x20the\x20table\x20entry\x20pointed\x20to\x20by\x20GuardIdentifier\x20has\x20value_type\x20in\x20[U8,U16,U32,U64,U128,U256]','failure_message':'E_GUARD_IDENTIFIER_NOT_NUMBER:\x20voting_guard\x20weight\x20must\x20be\x20numeric','verification_location':'Move\x20Arbitration','pitfall_number':0x9},{'id':'BINDING_02','name':'Repository\x20id_from_submission\x20Address','description':'The\x20table\x20entry\x20referenced\x20by\x20Repository\x20write_guard\x27s\x20id_from_submission\x20must\x20be\x20of\x20Address\x20type','category':'binding','phase':'creation','validation_logic':'If\x20binding=write_guard\x20and\x20id_from_submission\x20is\x20set,\x20table[id_from_submission].value_type\x20===\x20Address','failure_message':'Repository\x20id_from_submission\x20must\x20be\x20Address\x20type','verification_location':'Move\x20Repository'},{'id':'BINDING_03','name':'Repository\x20data_from_submission\x20type\x20match','description':'The\x20table\x20entry\x20referenced\x20by\x20Repository\x20write_guard\x27s\x20data_from_submission\x20must\x20match\x20the\x20Repository\x20value_type','category':'binding','phase':'creation','validation_logic':'If\x20binding=write_guard\x20and\x20data_from_submission\x20is\x20set,\x20table[data_from_submission].value_type\x20===\x20Repository.value_type','failure_message':'Repository\x20data_from_submission\x20type\x20mismatch','verification_location':'Move\x20Repository'},{'id':'INPUT_01','name':'root\x20byte\x20stream\x20non-empty','description':'The\x20serialized\x20byte\x20stream\x20of\x20root\x20cannot\x20be\x20empty','category':'input','phase':'creation','validation_logic':'input.length\x20>\x200','failure_message':'Input\x20cannot\x20be\x20empty','verification_location':'SDK\x20newGuard'},{'id':'INPUT_02','name':'root\x20byte\x20stream\x20≤\x20MAX_INPUT_SIZE','description':'The\x20serialized\x20byte\x20stream\x20of\x20root\x20must\x20not\x20exceed\x20MAX_INPUT_SIZE','category':'input','phase':'creation','validation_logic':'input.length\x20<=\x20MAX_INPUT_SIZE','failure_message':'Input\x20size\x20exceeds\x20maximum\x20limit','verification_location':'SDK\x20newGuard'},{'id':'IMMUTABLE_01','name':'Guard\x20immutable=true\x20after\x20creation','description':'After\x20creation,\x20a\x20Guard\x20cannot\x20be\x20modified\x20or\x20deleted\x20(CREATE-only)','category':'immutable','phase':'creation','validation_logic':'After\x20guard::create,\x20the\x20immutable\x20field\x20is\x20set\x20to\x20true','failure_message':'Guard\x20is\x20immutable\x20after\x20creation','verification_location':'Move\x20guard::create'},{'id':'RUN_IMMUTABLE_01','name':'Guard\x20must\x20be\x20immutable=true\x20to\x20verify','description':'At\x20runtime\x20verification,\x20the\x20Guard\x20must\x20be\x20frozen\x20(immutable=true)','category':'immutable','phase':'runtime','validation_logic':'guard.immutable\x20===\x20true','failure_message':'Guard\x20must\x20be\x20immutable\x20to\x20verify','verification_location':'native\x20verify_guard\x20L497-506'},{'id':'RUN_SUB_01','name':'submission\x20type\x20byte\x20matches\x20table\x20declaration','description':'The\x20value[0]\x20(type\x20byte)\x20of\x20submission\x20must\x20match\x20the\x20value_type\x20declared\x20in\x20the\x20table','category':'table','phase':'runtime','validation_logic':'submission_value[0]\x20===\x20table[identifier].value_type','failure_message':'Submission\x20type\x20byte\x20does\x20not\x20match\x20table\x20declaration','verification_location':'native\x20parse_table_items\x20L306'},{'id':'RUN_SUB_02','name':'table\x20entries\x20with\x20b_submission=true\x20must\x20be\x20found\x20in\x20submission','description':'All\x20table\x20entries\x20declared\x20as\x20submitted\x20must\x20have\x20corresponding\x20submission\x20data','category':'table','phase':'runtime','validation_logic':'forall\x20identifier\x20in\x20table\x20where\x20b_submission=true:\x20identifier\x20in\x20submission_map','failure_message':'Missing\x20submission\x20for\x20declared\x20b_submission=true\x20table\x20entry','verification_location':'native\x20parse_table_items\x20L301-321'},{'id':'RUN_SUB_03','name':'submission\x20total\x20bytes\x20≤\x20MAX_SUBMISSION_SIZE_PASSPORT\x20('+MAX_SUBMISSION_SIZE_PASSPORT+')','description':'The\x20total\x20bytes\x20of\x20all\x20data\x20submitted\x20at\x20runtime\x20must\x20not\x20exceed\x20'+MAX_SUBMISSION_SIZE_PASSPORT,'category':'table','phase':'runtime','validation_logic':'total_submission_bytes\x20<=\x20'+MAX_SUBMISSION_SIZE_PASSPORT,'failure_message':'Submission\x20exceeds\x20MAX_SUBMISSION_SIZE_PASSPORT\x20('+MAX_SUBMISSION_SIZE_PASSPORT+'\x20bytes)','verification_location':'Move\x20verify\x20L252'},{'id':'RUN_WITNESS_01','name':'witness\x20derivation\x20source\x20object\x20must\x20have\x20the\x20required\x20relation\x20field','description':'When\x20witness\x20conversion\x20occurs,\x20the\x20source\x20object\x20must\x20contain\x20the\x20relation\x20field\x20needed\x20for\x20derivation','category':'witness','phase':'runtime','validation_logic':'The\x20source\x20object\x20exists\x20and\x20contains\x20the\x20field\x20required\x20for\x20witness\x20derivation\x20(e.g.\x20order.progress\x20field\x20is\x20non-empty)','failure_message':'Witness\x20source\x20object\x20missing\x20required\x20field\x20for\x20derivation','verification_location':'native\x20convert_witness'},{'id':'RUN_WITNESS_02','name':'witness-derived\x20target\x20object\x20must\x20exist','description':'The\x20target\x20object\x20derived\x20by\x20witness\x20must\x20exist\x20on-chain','category':'witness','phase':'runtime','validation_logic':'The\x20derived\x20target\x20object\x20ID\x20exists\x20on-chain','failure_message':'Witness\x20derived\x20target\x20object\x20does\x20not\x20exist','verification_location':'native\x20convert_witness'},{'id':'RUN_QUERY_01','name':'query\x20target\x20object\x20must\x20exist\x20and\x20type\x20match','description':'The\x20target\x20object\x20of\x20a\x20query\x20must\x20exist\x20on-chain\x20and\x20its\x20type\x20must\x20match','category':'query','phase':'runtime','validation_logic':'Target\x20object\x20exists\x20&&\x20object\x20type\x20matches\x20query.objectType','failure_message':'Query\x20target\x20object\x20does\x20not\x20exist\x20or\x20type\x20mismatch','verification_location':'native\x20process_object_query'},{'id':'RUN_IMPACK_01','name':'at\x20least\x20one\x20impack\x20guard','description':'Passport\x20verification\x20requires\x20at\x20least\x20one\x20impack\x20guard','category':'runtime','phase':'runtime','validation_logic':'impack_list.length\x20>=\x201\x20(note:\x20impack_list\x20is\x20always\x20empty\x20during\x20verify\x20phase;\x20this\x20constraint\x20is\x20checked\x20in\x20result_for_permission\x20phase)','failure_message':'No\x20impack\x20guard\x20found','verification_location':'Move\x20verify\x20L281'},{'id':'RUN_IMPACK_02','name':'impack\x20guard\x20failure\x20fails\x20the\x20entire\x20passport','description':'If\x20any\x20impack\x20guard\x20verification\x20fails,\x20the\x20entire\x20passport\x20verification\x20fails','category':'runtime','phase':'runtime','validation_logic':'forall\x20guard\x20in\x20impack_list:\x20guard.result\x20===\x20true','failure_message':'Impack\x20guard\x20verification\x20failed','verification_location':'Move\x20verify\x20L270-275'},{'id':'RUN_TX_01','name':'Passport\x20tx_hash\x20must\x20match\x20the\x20current\x20transaction','description':'The\x20tx_hash\x20recorded\x20in\x20the\x20Passport\x20must\x20match\x20the\x20hash\x20of\x20the\x20currently\x20executing\x20transaction','category':'runtime','phase':'runtime','validation_logic':'passport.tx_hash\x20===\x20current_tx_hash','failure_message':'Passport\x20tx_hash\x20does\x20not\x20match\x20current\x20transaction','verification_location':'Move\x20verify\x20L231'},{'id':'RUN_RELY_01','name':'rely\x20guard\x20must\x20have\x20been\x20added\x20to\x20passport','description':'Guards\x20relied\x20on\x20must\x20have\x20been\x20registered\x20in\x20the\x20passport','category':'rely','phase':'runtime','validation_logic':'forall\x20guard\x20in\x20rely.guards:\x20guard\x20in\x20passport.relies','failure_message':'Rely\x20guard\x20not\x20added\x20to\x20passport','verification_location':'Move\x20calculate_relies_result'}];export function matchSemanticPattern(a){const b=a['toLowerCase']();return SEMANTIC_TO_SCHEMA_RULES['filter'](c=>c['match_keywords']['some'](d=>b['includes'](d['toLowerCase']())));}export function explainNode(a){return SCHEMA_TO_SEMANTIC_RULES['find'](b=>b['element_type']==='node'&&b['type_name']===a);}export function explainWitness(a){const b={0x64:'TypeOrderProgress',0x65:'TypeOrderMachine',0x66:'TypeOrderService',0x67:'TypeProgressMachine',0x68:'TypeArbOrder',0x69:'TypeArbArbitration',0x6a:'TypeArbProgress',0x6b:'TypeArbMachine',0x6c:'TypeArbService'},c=b[a];return SCHEMA_TO_SEMANTIC_RULES['find'](d=>d['element_type']==='witness'&&d['type_name']===c);}export function explainContext(a){return SCHEMA_TO_SEMANTIC_RULES['find'](b=>b['element_type']==='context'&&b['type_name']===a);}export function getConstraintsByCategory(a){return GUARD_CONSTRAINT_RULES['filter'](b=>b['category']===a);}export function getConstraintsByPhase(a){return GUARD_CONSTRAINT_RULES['filter'](b=>b['phase']===a);}export function getPatternById(a){return SEMANTIC_TO_SCHEMA_RULES['find'](b=>b['id']===a);}export function getDataSourceCombinations(){return[...new Set(SEMANTIC_TO_SCHEMA_RULES['map'](a=>a['data_source_combination']))];}