@crediolabs/policy-synth 0.1.18 → 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.InstallPolicyInputSchema = exports.NETWORK_PASSPHRASES = exports.DEFAULT_AUTH_VALID_UNTIL_LEDGERS = 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.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
@@ -159,17 +116,10 @@ exports.ComposeUserResponsesSchema = zod_1.z
         .array(zod_1.z.string().refine(address_ts_1.isStellarAddress, 'must be a Stellar address (G... or C...)'))
         .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(),
@@ -183,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
@@ -232,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.
@@ -262,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() }),
@@ -308,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,
     }),
@@ -349,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
@@ -393,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
@@ -404,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') }),
@@ -424,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()
@@ -448,18 +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 = 'CDR4NLV22STCXFGZPNKDQTEANWLF7LZ6AJLY6B7CLJXKHDZGYJWIOKGP';
-/** Pinned interpreter address (mainnet). Mainnet
- *  has now been deployed (2026-08-04); the mainnet interpreter IS the binary
- *  that was exercised on testnet (same wasm sha256, see
- *  PINNED_INTERPRETER_WASM_SHA256). The address differs because instance
- *  ids are network-scoped. UNAUDITED at the time of writing. */
-exports.PINNED_INTERPRETER_MAINNET_ADDRESS = 'CALZAMUPREIRY4TULBEXIK77AUTOEJG63XLCPUWEHHQDOVK6ZVVS7VQ2';
+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.
+ *
+ *  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 = '6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443';
+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
@@ -482,9 +322,6 @@ 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). */
@@ -521,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

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;