@crediolabs/policy-synth 0.2.0 → 0.3.0

package/dist-cjs/run/schemas.js

@@ -9,14 +9,14 @@
 //
 // i128 amounts and other large integers are carried as base-10 decimal strings
 // end-to-end. Networks are pinned to the same closed set the core defines.
-// The discriminated union on `source` exposes BOTH synthesize_policy
-// front-ends through a single tool input.
+// `source` is a single-variant discriminator (`recording`); it stays a union
+// so an unknown value is rejected with a discriminator error.
 //
 // This module is the SINGLE source of truth for these shapes. The MCP package
 // imports them here so its tool-shape bindings stay in step; the CLI imports
 // them here so it can build the same args envelope the MCP transport builds.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolErrorSchema = exports.GetInterpreterInfoInputSchema = exports.RevokePolicyInputSchema = exports.MergePolicyInputSchema = exports.InstallPolicyInputSchema = exports.NETWORK_PASSPHRASES = exports.DEFAULT_AUTH_VALID_UNTIL_LEDGERS = exports.RPC_URL_BY_NETWORK = exports.PINNED_INTERPRETER_WASM_SHA256_BY_NETWORK = exports.PINNED_INTERPRETER_ADDRESS_BY_NETWORK = exports.MAINNET_RPC_URL = exports.TESTNET_RPC_URL = exports.PINNED_INTERPRETER_GRAMMAR_VERSION = exports.PINNED_INTERPRETER_WASM_SHA256_TESTNET = exports.PINNED_INTERPRETER_WASM_SHA256 = exports.PINNED_INTERPRETER_MAINNET_ADDRESS = exports.PINNED_INTERPRETER_TESTNET_ADDRESS = exports.VerifyPolicyInputSchema = exports.SimulatePolicyInputSchema = exports.OraclePriceFixtureSchema = exports.PredicateNodeSchema = exports.PredicateLeafSchema = exports.SynthesizePolicyInputSchema = exports.SynthesizePolicyRecordingInputSchema = exports.InterpreterOptionsSchema = exports.SynthesizePolicyMandateInputSchema = exports.RecordTransactionInputSchema = exports.OzAdapterConfigSchema = exports.ComposeUserResponsesSchema = exports.MandateSpecSchema = exports.RecordedTransactionSchema = exports.ParseConfidenceSchema = exports.OnChainEventSchema = exports.TokenMovementSchema = exports.ContractInvocationSchema = exports.ScValSchema = exports.NetworkSchema = void 0;
+exports.ToolErrorSchema = exports.GetInterpreterInfoInputSchema = exports.RevokePolicyInputSchema = exports.InstallPolicyInputSchema = exports.NETWORK_PASSPHRASES = exports.RPC_URL_BY_NETWORK = exports.PINNED_INTERPRETER_ADDRESS_BY_NETWORK = exports.MAINNET_RPC_URL = exports.TESTNET_RPC_URL = exports.PINNED_INTERPRETER_GRAMMAR_VERSION = exports.PINNED_INTERPRETER_WASM_SHA256 = exports.PINNED_INTERPRETER_MAINNET_ADDRESS = exports.PINNED_INTERPRETER_TESTNET_ADDRESS = exports.VerifyPolicyInputSchema = exports.SimulatePolicyInputSchema = exports.PredicateNodeSchema = exports.PredicateLeafSchema = exports.SynthesizePolicyInputSchema = exports.InterpreterOptionsSchema = exports.RecordTransactionInputSchema = exports.ComposeUserResponsesSchema = exports.RecordedTransactionSchema = exports.ParseConfidenceSchema = exports.OnChainEventSchema = exports.TokenMovementSchema = exports.ContractInvocationSchema = exports.ScValSchema = exports.NetworkSchema = void 0;
 const zod_1 = require("zod");
 const address_ts_1 = require("../synth/address.js");
 /** Soroban `valid_until` is a u32 ledger sequence; a value above this cannot be
@@ -101,56 +101,13 @@ exports.RecordedTransactionSchema = zod_1.z
     sourceAccount: zod_1.z.string(),
 })
     .passthrough();
-/** MandateSpec mirrors the core MandateSpec. The deterministic Mandate
- *  front-end needs no parseConfidence; the tool adapter injects the full
- *  confidence after synthesis so the orchestrator can compare. */
-exports.MandateSpecSchema = zod_1.z
-    .object({
-    chain: zod_1.z.literal('stellar'),
-    contract: zod_1.z.string(),
-    method: zod_1.z.string().optional(),
-    spendingLimit: zod_1.z
-        .object({
-        token: zod_1.z.string(),
-        limit: zod_1.z.string().regex(/^[0-9]+$/),
-        windowSeconds: zod_1.z.number().int().positive(),
-    })
-        .optional(),
-    // A threshold of 0 means "0 approvals", which is not a real M-of-N gate.
-    approvalThreshold: zod_1.z.number().int().positive().optional(),
-    recipients: zod_1.z.array(zod_1.z.string()).optional(),
-    expiry: zod_1.z
-        .object({
-        validUntilLedger: zod_1.z.number().int().positive().max(U32_MAX).optional(),
-        validUntilUnixSeconds: zod_1.z.number().int().positive().optional(),
-    })
-        .optional(),
-})
-    .passthrough()
-    // TS-F4/F6: a `recipients` allowlist is only meaningful against a SEP-41
-    // method whose arg 1 IS the recipient (SAC/SEP-41 `transfer(from, to,
-    // amount)` and SEP-41 `mint(to, amount)`). Without this gate the
-    // `to-ir.ts` lowering pins the allowlist to `RECIPIENT_ARG_INDEX = 1`
-    // for any contract+method, which would let a non-SEP-41 method's
-    // arg[1] (e.g. an amount, an op type, an arbitrary address payload)
-    // be silently constrained as if it were a recipient. Refusing
-    // non-SEP-41 methods at the boundary is the fail-closed shape.
-    .refine((v) => v.recipients === undefined ||
-    v.recipients.length === 0 ||
-    v.method === 'transfer' ||
-    v.method === 'mint', {
-    message: 'recipients is only valid when method is a SEP-41 method (transfer or mint); other methods do not have a recipient at arg[1]',
-});
-/** ComposeUserResponses mirrors the core. */
 exports.ComposeUserResponsesSchema = zod_1.z
     .object({
-    windowSeconds: zod_1.z.number().int().positive().optional(),
     validUntilLedger: zod_1.z.number().int().positive().max(U32_MAX).optional(),
     limitAmount: zod_1.z
         .string()
         .regex(/^[0-9]+$/)
         .optional(),
-    invocationLimit: zod_1.z.number().int().positive().optional(),
     // Swap recipient allowlist (SoroSwap call_arg[3]). Each entry must be a
     // Stellar address (G... wallet or C... contract); supplying it REPLACES the
     // default pin to the recorded recipient. Validated with the shared StrKey
@@ -158,33 +115,11 @@ exports.ComposeUserResponsesSchema = zod_1.z
     swapRecipientAllowlist: zod_1.z
         .array(zod_1.z.string().refine(address_ts_1.isStellarAddress, 'must be a Stellar address (G... or C...)'))
         .optional(),
-    // Per-asset oracle-price bound, one entry per asset. Reaches
-    // `compose-from-recording` and emits an `oracle_price` compare. Declared
-    // here because the object is `.passthrough()`: the field already worked
-    // undeclared, which left the accepted surface wider than the documented
-    // one. `decimals` is REQUIRED - oracle prices normalise to 9 dp and a
-    // threshold silently assumed to share that basis is what let a raw 14-dp
-    // bound permit everything.
-    oraclePriceBound: zod_1.z
-        .array(zod_1.z.object({
-        asset: zod_1.z.string().refine(address_ts_1.isStellarAddress, 'must be a Stellar address (G... or C...)'),
-        operator: zod_1.z.enum(['eq', 'lt', 'lte', 'gt', 'gte']),
-        value: zod_1.z.string().regex(/^[0-9]+$/),
-        decimals: zod_1.z.number().int().min(0).max(U32_MAX),
-    }))
-        .optional(),
 })
-    .passthrough();
-/** OzAdapterConfig - the per-network OZ built-in instance addresses. */
-exports.OzAdapterConfigSchema = zod_1.z.object({
-    network: exports.NetworkSchema,
-    instances: zod_1.z.object({
-        spending_limit: zod_1.z.string(),
-        simple_threshold: zod_1.z.string(),
-        weighted_threshold: zod_1.z.string(),
-    }),
-});
-// ===== record_transaction =====
+    // Strict, not passthrough: a response key the synthesiser no longer reads
+    // (or a typo) would otherwise be accepted in silence, and the caller would
+    // believe they had answered a question that is still open.
+    .strict();
 exports.RecordTransactionInputSchema = zod_1.z
     .object({
     hash: zod_1.z.string().min(1).optional(),
@@ -198,45 +133,17 @@ exports.RecordTransactionInputSchema = zod_1.z
     .refine((v) => Boolean(v.hash) || Boolean(v.xdr), {
     message: 'one of `hash` or `xdr` is required',
 });
-// ===== synthesize_policy =====
-//
-// Discriminated union on `source` exposes BOTH front-ends through ONE tool.
-// - `source: 'mandate'` -> calls synthesizeFromMandate
-// - `source: 'recording'` -> calls synthesizeFromRecording
-exports.SynthesizePolicyMandateInputSchema = zod_1.z.object({
-    source: zod_1.z.literal('mandate'),
-    mandate: exports.MandateSpecSchema,
-    ozConfig: exports.OzAdapterConfigSchema.optional(),
-    // --explain opt-in. When true, the orchestrator attaches the
-    // in-memory predicate tree (null for the mandate path) + a minimal
-    // honest SimulationResult to the success envelope. Absent or false
-    // -> the success envelope is unchanged (byte-identical to today).
-    explain: zod_1.z.boolean().optional(),
-});
-/** Interpreter opt-in for the recording path. Present -> constraints OZ cannot
- *  express (per-method scoping, invocation-count windows, oracle bounds, exact
- *  hop paths) lower to a real interpreter predicate document instead of being
- *  surfaced as warnings. The core deep-validates `smartAccountAddress` (a C...
- *  contract, not the recording's G... source) and the tighten-only oracle
- *  bounds; the schema stays light so the core owns the friendly ToolErrors. */
 exports.InterpreterOptionsSchema = zod_1.z.object({
     smartAccountAddress: zod_1.z.string(),
     installNonce: zod_1.z.number().int().positive().optional(),
-    oracleParams: zod_1.z
-        .object({
-        maxStalenessSeconds: zod_1.z.number().int().positive().optional(),
-        maxDeviationBps: zod_1.z.number().int().positive().optional(),
-    })
-        .optional(),
 });
-exports.SynthesizePolicyRecordingInputSchema = zod_1.z.object({
+exports.SynthesizePolicyInputSchema = zod_1.z.object({
     source: zod_1.z.literal('recording'),
     recordedTx: exports.RecordedTransactionSchema,
     network: exports.NetworkSchema,
     userResponses: exports.ComposeUserResponsesSchema.optional(),
     confidenceOverride: zod_1.z.object({ threshold: zod_1.z.number().min(0).max(1) }).optional(),
     interpreter: exports.InterpreterOptionsSchema.optional(),
-    ozConfig: exports.OzAdapterConfigSchema.optional(),
     // --explain opt-in. When true, the orchestrator attaches the
     // in-memory PredicateNode + the corresponding SimulationResult
     // (real one from the self-verify pipeline when the interpreter is
@@ -247,10 +154,6 @@ exports.SynthesizePolicyRecordingInputSchema = zod_1.z.object({
     // explain.
     explain: zod_1.z.boolean().optional(),
 });
-exports.SynthesizePolicyInputSchema = zod_1.z.discriminatedUnion('source', [
-    exports.SynthesizePolicyMandateInputSchema,
-    exports.SynthesizePolicyRecordingInputSchema,
-]);
 // ===== PredicateNode / PredicateLeaf =====
 //
 // Hand-written zod mirrors of the predicate grammar in types.ts:132-180.
@@ -277,41 +180,6 @@ exports.PredicateLeafSchema = zod_1.z.lazy(() => zod_1.z.union([
         element: zod_1.z.number().int().nonnegative(),
         field: zod_1.z.string(),
     }),
-    // num/den are i128 on chain; JSON numbers lose precision past 2^53,
-    // so the wire is a decimal string. The contract refuses `den == 0` and
-    // `num <= 0` / `den <= 0` at install (types.ts:162-163 + the install
-    // gate); mirroring that bound here closes the gap where simulate /
-    // verify green-light a policy the install gate will reject. The
-    // positive-only regex is the cheapest unambiguous check.
-    zod_1.z.object({
-        kind: zod_1.z.literal('call_arg_scaled'),
-        index: zod_1.z.number().int().nonnegative(),
-        num: zod_1.z.string().regex(/^[1-9][0-9]*$/),
-        den: zod_1.z.string().regex(/^[1-9][0-9]*$/),
-    }),
-    zod_1.z.object({ kind: zod_1.z.literal('amount'), token: zod_1.z.string() }),
-    zod_1.z.object({
-        kind: zod_1.z.literal('window_spent'),
-        token: zod_1.z.string(),
-        windowSeconds: zod_1.z.number().int().positive(),
-    }),
-    zod_1.z.object({ kind: zod_1.z.literal('now') }),
-    // `valid_until` is NOT in the public predicate grammar: the encoder +
-    // decoder already throw on it, so accepting it here would let a
-    // hand-crafted payload through the schema and only surface a 200+
-    // character internal-commentary error at encode time. Drop it - the
-    // policy's expiry is carried at the install layer (MandateSpec +
-    // validUntilLedger) instead.
-    zod_1.z.object({
-        kind: zod_1.z.literal('invocation_count_in_window'),
-        windowSecs: zod_1.z.number().int().positive(),
-    }),
-    zod_1.z.object({ kind: zod_1.z.literal('oracle_price'), asset: zod_1.z.string() }),
-    zod_1.z.object({
-        kind: zod_1.z.literal('oracle_threshold'),
-        value: zod_1.z.string().regex(/^-?[0-9]+$/),
-        decimals: zod_1.z.number().int().nonnegative(),
-    }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_address'), value: zod_1.z.string() }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_i128'), value: zod_1.z.string().regex(/^-?[0-9]+$/) }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_symbol'), value: zod_1.z.string() }),
@@ -323,36 +191,20 @@ exports.PredicateLeafSchema = zod_1.z.lazy(() => zod_1.z.union([
         kind: zod_1.z.literal('literal_u32'),
         value: zod_1.z.number().int().nonnegative().max(U32_MAX),
     }),
-    zod_1.z.object({ kind: zod_1.z.literal('literal_u64'), value: zod_1.z.string().regex(/^[0-9]+$/) }),
-    // `literal_bytes` is hex on chain. `Buffer.from(value, 'hex')` silently
-    // drops non-hex chars AND yields an empty buffer when the whole input
-    // is non-hex - so a user passing 'zzzz' would get a predicate that
-    // compares against empty bytes instead of being rejected. The
-    // strict even-length hex regex closes that gap at the boundary.
-    zod_1.z.object({
-        kind: zod_1.z.literal('literal_bytes'),
-        value: zod_1.z
-            .string()
-            .regex(/^[0-9a-fA-F]*$/)
-            .refine((v) => v.length % 2 === 0, 'must be even-length hex'),
-    }),
     // elements are themselves PredicateLeaf; lazy to break the cycle.
     zod_1.z.object({ kind: zod_1.z.literal('literal_vec'), elements: zod_1.z.array(exports.PredicateLeafSchema) }),
 ]));
 /** PredicateNode mirrors the core `PredicateNode` union. Recursive through
- *  `and`/`or`/`not`; the lazy + annotation pattern keeps the recursion
- *  type-safe. */
+ *  `and`; the lazy + annotation pattern keeps the recursion type-safe. */
 exports.PredicateNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
     zod_1.z.object({ op: zod_1.z.literal('and'), children: zod_1.z.array(exports.PredicateNodeSchema) }),
-    zod_1.z.object({ op: zod_1.z.literal('or'), children: zod_1.z.array(exports.PredicateNodeSchema) }),
-    zod_1.z.object({ op: zod_1.z.literal('not'), child: exports.PredicateNodeSchema }),
     zod_1.z.object({
         op: zod_1.z.literal('eq'),
         left: exports.PredicateLeafSchema,
         right: exports.PredicateLeafSchema,
     }),
     zod_1.z.object({
-        op: zod_1.z.enum(['lt', 'lte', 'gt', 'gte']),
+        op: zod_1.z.literal('lte'),
         left: exports.PredicateLeafSchema,
         right: exports.PredicateLeafSchema,
     }),
@@ -364,38 +216,16 @@ exports.PredicateNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
 ]));
 // ===== simulate_policy / verify_policy =====
 //
-// The oracle fixture shape mirrors `SimulateOptions` / `VerifyOptions`
-// in packages/policy-synth/src/verify/{simulate,verify}.ts - the same
-// sorted set of error enum values is used by both engines. u32
-// `validUntilLedger` is bounded at the boundary so a hand-crafted
-// payload cannot leak a u32 overflow into the engine's permit context.
-/** Oracle price fixture - mirror of the entry type in `SimulateOptions` /
- *  `VerifyOptions`. Discriminated by presence of `error` vs `price`. */
-exports.OraclePriceFixtureSchema = zod_1.z.union([
-    zod_1.z.object({
-        price: zod_1.z.string().regex(/^[0-9]+$/),
-        timestampSeconds: zod_1.z.number().int().nonnegative(),
-    }),
-    zod_1.z.object({
-        error: zod_1.z.enum(['stale', 'missing', 'deviation', 'paused', 'decimals', 'fingerprint']),
-    }),
-]);
+// Both tools evaluate the same predicate against the same recording, so they
+// take the same input. A null predicate used to mean "OZ built-in policies
+// only"; that backend is gone, so every policy carries a predicate and there is
+// nothing to simulate without one.
 exports.SimulatePolicyInputSchema = zod_1.z.object({
-    // simulatePolicy accepts a null predicate (OZ-only policy); verifyPolicy
-    // does not. The asymmetry is mirrored at the schema boundary.
-    predicate: exports.PredicateNodeSchema.nullable(),
-    permitTx: exports.RecordedTransactionSchema,
-    validUntilLedger: zod_1.z.number().int().positive().max(U32_MAX).optional(),
-    oraclePricesByAsset: zod_1.z.record(zod_1.z.string(), exports.OraclePriceFixtureSchema).optional(),
-});
-exports.VerifyPolicyInputSchema = zod_1.z.object({
-    // verifyPolicy requires a non-null predicate; the engine refuses
-    // `null` outright. The schema mirrors that contract.
     predicate: exports.PredicateNodeSchema,
     permitTx: exports.RecordedTransactionSchema,
     validUntilLedger: zod_1.z.number().int().positive().max(U32_MAX).optional(),
-    oraclePricesByAsset: zod_1.z.record(zod_1.z.string(), exports.OraclePriceFixtureSchema).optional(),
 });
+exports.VerifyPolicyInputSchema = exports.SimulatePolicyInputSchema;
 // ===== install_policy / revoke_policy / get_interpreter_info =====
 //
 // The install/revoke pair drives the OZ smart-account admin flow. Both surface
@@ -408,7 +238,7 @@ exports.VerifyPolicyInputSchema = zod_1.z.object({
 // optional `grammar_version()` RPC call to check whether the deployed contract
 // matches the pin. A mismatch is worth MORE than a fabricated audit field.
 //
-// All three input schemas live BELOW the MandateSpecSchemaForRule declaration
+// All three input schemas live BELOW the ContextRuleDraftSchema declaration
 // so the const reference there is not in the temporal dead zone (no JS hoisting
 // for `const`).
 /** Minimal rule-draft schema for the install input. Mirrors ContextRuleDraft
@@ -419,7 +249,7 @@ exports.VerifyPolicyInputSchema = zod_1.z.object({
  *  the temporal dead zone (no JS hoisting for `const`). */
 const MAX_SIGNERS_PER_RULE = 15;
 const MAX_POLICIES_PER_RULE = 5;
-const MandateSpecSchemaForRule = zod_1.z
+const ContextRuleDraftSchema = zod_1.z
     .object({
     contextRuleType: zod_1.z.discriminatedUnion('kind', [
         zod_1.z.object({ kind: zod_1.z.literal('default') }),
@@ -439,21 +269,11 @@ const MandateSpecSchemaForRule = zod_1.z
     ]))
         .max(MAX_SIGNERS_PER_RULE),
     policies: zod_1.z
-        .array(zod_1.z.discriminatedUnion('kind', [
-        zod_1.z.object({
-            kind: zod_1.z.literal('interpreter'),
-            interpreterAddress: zod_1.z.string(),
-            predicateBlobBase64: zod_1.z.string().min(1),
-        }),
-        zod_1.z.object({
-            kind: zod_1.z.literal('oz_builtin'),
-            primitive: zod_1.z.object({
-                primitive: zod_1.z.enum(['spending_limit', 'simple_threshold', 'weighted_threshold']),
-                params: zod_1.z.record(zod_1.z.unknown()),
-            }),
-            instanceAddress: zod_1.z.string(),
-        }),
-    ]))
+        .array(zod_1.z.object({
+        kind: zod_1.z.literal('interpreter'),
+        interpreterAddress: zod_1.z.string(),
+        predicateBlobBase64: zod_1.z.string().min(1),
+    }))
         .max(MAX_POLICIES_PER_RULE),
 })
     .passthrough()
@@ -463,27 +283,23 @@ const MandateSpecSchemaForRule = zod_1.z
 // existing four.
 /** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-exports.PINNED_INTERPRETER_TESTNET_ADDRESS = 'CALHNU4LXZRKFAXYRBODTGDANTNXHJPBTJNYGLUWLIFIP24NWSGWIE4K';
-/** Pinned interpreter address (mainnet), deployed 2026-08-04.
- *  UNAUDITED at the time of writing. */
-exports.PINNED_INTERPRETER_MAINNET_ADDRESS = 'CALZAMUPREIRY4TULBEXIK77AUTOEJG63XLCPUWEHHQDOVK6ZVVS7VQ2';
-/** Pinned interpreter wasm sha256 (hex), mainnet.
+exports.PINNED_INTERPRETER_TESTNET_ADDRESS = 'CCL336TCK2Y5OFNRCMN2M3HVPBCEX4PW5H6EQ5VW5NPMXOCP4ESB5XR4';
+/** Pinned interpreter address (mainnet), redeployed 2026-08-22 from a reproducible build. The mainnet
+ *  interpreter IS the binary exercised on testnet - both instances were created
+ *  from the same uploaded wasm hash (see PINNED_INTERPRETER_WASM_SHA256), and
+ *  both were read back with `grammar_version()` returning 3. The address differs
+ *  because instance ids are network-scoped. UNAUDITED at the time of writing.
  *
- *  The two networks no longer run the same binary. Testnet carries the
- *  selector-leaf minimum and the signer-set cap; mainnet predates both. Read
- *  the hash through `PINNED_INTERPRETER_WASM_SHA256_BY_NETWORK` rather than
- *  this constant unless mainnet is specifically what is meant, or
- *  `get_interpreter_info` will report a hash the queried network does not
- *  run. */
-exports.PINNED_INTERPRETER_WASM_SHA256 = '6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443';
-/** Pinned interpreter wasm sha256 (hex), testnet. Byte-identical to the
- *  artifact built from `contracts/policy-interpreter` at the commit that
- *  introduced errors 216 and 217, verified by fetching the deployed wasm back
- *  off chain. */
-exports.PINNED_INTERPRETER_WASM_SHA256_TESTNET = 'a4d58bc88fd82bbb8e223941ba5889db919717fae92ced13f6f55bfe583b8e22';
+ *  These four constants move together or not at all. The grammar version and
+ *  wasm hash are single values covering BOTH networks, so re-pinning one network
+ *  alone would have the builder emit a version the other network refuses - with
+ *  a green test run, since `grammar-version-parity.test.ts` would then pass. */
+exports.PINNED_INTERPRETER_MAINNET_ADDRESS = 'CBZXLSTQUITBFZHQH6XRXF3XIVRQR4RHRI64Q5WELS5KGY3ZKJPFWDPF';
+/** Pinned interpreter wasm sha256 (hex). */
+exports.PINNED_INTERPRETER_WASM_SHA256 = 'a2b36e8ac5a61caf3757af26aa79e83f2995b451099f44772383806a55fe3414';
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
  *  contracts/policy-interpreter/src/version.rs). */
-exports.PINNED_INTERPRETER_GRAMMAR_VERSION = 1;
+exports.PINNED_INTERPRETER_GRAMMAR_VERSION = 3;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
  *  than a Server; the two are deliberately different surfaces, so this is
@@ -494,25 +310,18 @@ exports.TESTNET_RPC_URL = 'https://soroban-testnet.stellar.org';
  *  RPC rather than always testnet. Public mainnet endpoint, the same one
  *  the deploy script hit during the 2026-08-04 mainnet rollout. */
 exports.MAINNET_RPC_URL = 'https://mainnet.sorobanrpc.com';
-/** Pin + RPC lookup for the gate enforcement. Addresses, RPCs and wasm
- *  hashes are all network-scoped: the networks diverged when the
- *  selector-leaf and signer-cap controls were deployed to testnet ahead of
- *  mainnet. */
+/** Pin + RPC lookup for the gate enforcement. The interpreters' wasm sha256
+ *  is identical across both networks (the same binary was uploaded both
+ *  places), so `PINNED_INTERPRETER_WASM_SHA256` stays
+ *  a single constant - only the addresses and RPCs are network-scoped. */
 exports.PINNED_INTERPRETER_ADDRESS_BY_NETWORK = {
     testnet: exports.PINNED_INTERPRETER_TESTNET_ADDRESS,
     mainnet: exports.PINNED_INTERPRETER_MAINNET_ADDRESS,
 };
-exports.PINNED_INTERPRETER_WASM_SHA256_BY_NETWORK = {
-    testnet: exports.PINNED_INTERPRETER_WASM_SHA256_TESTNET,
-    mainnet: exports.PINNED_INTERPRETER_WASM_SHA256,
-};
 exports.RPC_URL_BY_NETWORK = {
     testnet: exports.TESTNET_RPC_URL,
     mainnet: exports.MAINNET_RPC_URL,
 };
-/** Soroban `valid_until` window (ledgers) added to the latest ledger when
- *  building the auth entry. ~25 minutes at 5s/ledger. */
-exports.DEFAULT_AUTH_VALID_UNTIL_LEDGERS = 300;
 /** Stellar network passphrases. Pinned here so the XDR envelope uses the
  *  matching passphrase when the wallet signs (a mismatch yields invalid
  *  hashes). */
@@ -549,7 +358,7 @@ exports.InstallPolicyInputSchema = zod_1.z
      *  pin and RPC pin do not move by themselves). */
     network: exports.NetworkSchema.optional(),
     /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape. */
-    rule: MandateSpecSchemaForRule,
+    rule: ContextRuleDraftSchema,
     /** Per-rule install nonce; 1 for a fresh install. */
     installNonce: zod_1.z.number().int().positive(),
     /** Optional RPC URL override. Defaults to the pinned RPC for the
@@ -569,50 +378,12 @@ exports.InstallPolicyInputSchema = zod_1.z
      *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
      *  the mainnet pin is its own deny-by-default anchor. */
     allowUnpinnedInterpreter: zod_1.z.boolean().optional(),
-    /** Opt-in to installing when a signer of this rule can already reach the
-     *  same calls through a context rule that has NO policy attached. OZ lets
-     *  the signer choose which rule authorises a call and enforces only that
-     *  rule's policies, so an unpoliced rule covering the same calls makes
-     *  this policy decorative. Default-deny, because the caller almost
-     *  certainly believes they are restricting something. */
-    allowAuthorityOverlap: zod_1.z.boolean().optional(),
-    /** Skip the cross-rule authority scan entirely. The scan costs one RPC
-     *  read per rule on the account; skipping it means the response carries
-     *  no statement about what the signers can already do. */
-    skipAuthorityScan: zod_1.z.boolean().optional(),
     /** Base fee in stroops; defaults to BASE_FEE (100). */
     baseFee: zod_1.z.number().int().positive().optional(),
 })
     .refine((v) => Boolean(v.smartAccount) && Boolean(v.sourceAccount), {
     message: 'smartAccount and sourceAccount are required',
 });
-/** `merge_policy` input.
- *
- *  The tightening remedy for a cross-rule overlap: replace a rule's predicate
- *  with the conjunction of it and a new one. Two transactions, in order,
- *  because OZ refuses to re-attach a policy already on the rule - so the
- *  caller runs `detach`, waits for it to confirm, then runs `reinstall`. */
-exports.MergePolicyInputSchema = zod_1.z
-    .object({
-    smartAccount: zod_1.z
-        .string()
-        .regex(STELLAR_CONTRACT_ADDRESS, 'smartAccount must be a Stellar contract address (C...)'),
-    sourceAccount: zod_1.z
-        .string()
-        .regex(STELLAR_ACCOUNT_ADDRESS, 'sourceAccount must be a Stellar account address (G...)'),
-    /** The rule whose predicate is being tightened. */
-    ruleId: zod_1.z.number().int().nonnegative(),
-    /** The predicate to conjoin, base64 canonical ScVal, as emitted by
-     *  `synthesize_policy`. */
-    incomingPredicateBlobBase64: zod_1.z.string().min(1),
-    /** Which half of the remedy to build. */
-    step: zod_1.z.enum(['detach', 'reinstall']),
-    network: exports.NetworkSchema.optional(),
-    rpcUrl: zod_1.z.string().url().optional(),
-    allowUnpinnedRpcUrl: zod_1.z.boolean().optional(),
-    baseFee: zod_1.z.number().int().positive().optional(),
-})
-    .strict();
 exports.RevokePolicyInputSchema = zod_1.z
     .object({
     /** The smart account contract address (C...). */

package/dist-cjs/seams/types.d.ts

@@ -25,9 +25,7 @@ export type CustodyMode = 'enforce' | 'log_only';
 /** What a backend can express. A construct needing a false flag is flagged
  *  `uncovered` by the adapter, never silently dropped. */
 export interface CustodyCapabilities {
-    supportsOraclePrice: boolean;
     supportsSpendWindow: boolean;
-    supportsInvocationCount: boolean;
     supportsTimeExpiry: boolean;
     supportsThreshold: boolean;
     supportsGeneralPredicate: boolean;

package/dist-cjs/simulate/deny-cases.d.ts

@@ -0,0 +1,26 @@
+import type { PredicateNode, ScVal } from '../types.ts';
+import type { EvalContext } from './evaluate.ts';
+export interface DenyCase {
+    dimension: string;
+    ctx: EvalContext;
+    /** Canonical reason the Rust interpreter returns for this dimension.
+     *  Optional: when set, `runHarness` asserts the TS evaluator emits this
+     *  exact string, so a future TS/Rust reason divergence fails CI. When
+     *  absent the case is only checked on the boolean decision. */
+    expectedReason?: string;
+}
+export interface GeneratedCases {
+    permit: EvalContext;
+    denies: DenyCase[];
+}
+/** Build deterministic model-evaluated alternatives without mutating the intended call.
+ *
+ * @param predicate   - the synthesized predicate
+ * @param permitCtx  - EvalContext for the intended (permitted) call
+ * @param dimensions - optional whitelist of dimension names to emit; when omitted
+ *                    all known dimensions (including over-permissiveness mutations)
+ *                    are emitted. */
+export declare function generateCases(predicate: PredicateNode, permitCtx: EvalContext, dimensions?: string[]): GeneratedCases;
+/** Deep-copy an ScVal so a mutation cannot alias the recorded call.
+ *  Exported so the permit-context builder shares this one implementation. */
+export declare function cloneScVal(value: ScVal, depth?: number): ScVal;