@crediolabs/policy-synth 0.2.0 → 0.3.1

package/src/types.ts

@@ -64,13 +64,11 @@ export const MAX_SCVAL_CLONE_DEPTH = 30 as const
  *    - MAX_DEPTH = 5:             3 walkthroughs need depth 2; budget = 2x growth + 1 for `not` chain.
  *    - MAX_LEAVES = 200:         allowlists (recipients, paths) typically < 100; budget = 2x + 1 nested allowlist.
  *    - MAX_PREDICATE_BYTES = 32 KB: well under the per-ledger-entry 64 KB persistent-storage limit.
- *    - MAX_ORACLE_READS = 6:     two-round confirmation per asset consumes 2 reads; cap accommodates a predicate that references up to 3 unique oracle assets (3 * 2 = 6 reads). Stays a fail-closed install-time cap.
  *    - MAX_IN_OPERAND_COUNT = 32: allowlist < 32 is a UX-natural bound. */
 export const PREDICATE_CAPS = {
   MAX_DEPTH: 5,
   MAX_LEAVES: 200,
   MAX_PREDICATE_BYTES: 32 * 1024,
-  MAX_ORACLE_READS: 6,
   MAX_IN_OPERAND_COUNT: 32,
 } as const
 
@@ -97,15 +95,23 @@ export type SignerDraft =
   | { kind: 'external'; verifier: string; keyBytes: string }
 
 /** Reference to one policy attached to a context rule. */
-export type PolicyRef =
-  | { kind: 'oz_builtin'; primitive: OZPrimitiveConfig; instanceAddress: string }
-  | { kind: 'interpreter'; interpreterAddress: string; predicateBlobBase64: string }
+export type PolicyRef = {
+  kind: 'interpreter'
+  interpreterAddress: string
+  predicateBlobBase64: string
+}
+
+/** Grammar version baked into the interpreter wasm, mirroring `SELF_VERSION` in
+ *  `contracts/policy-interpreter/src/version.rs`. Every value this package puts on
+ *  the wire derives from here; `grammar-version-parity.test.ts` pins it to the
+ *  contract so a skew cannot pass a green test run. */
+export const GRAMMAR_VERSION = 3 as const
 
 /** A serialised predicate document stored against a (smart_account, rule_id) pair. */
 export interface PolicyDocument {
   /** Grammar version baked into the interpreter wasm. Fail-closed strict match at install
    *  AND at evaluate (defence in depth). NOT the per-edit revision. */
-  grammarVersion: 1
+  grammarVersion: typeof GRAMMAR_VERSION
   /** Per-rule install nonce. Must equal the interpreter's stored nonce + 1 at install.
    *  First install accepts nonce = 1 with stored nonce = 0. Re-install is structurally
    *  possible by incrementing the nonce; uninstall removes the nonce with state so a
@@ -117,24 +123,13 @@ export interface PolicyDocument {
   /** Hash of the post-canonicalisation bytes of encodedPredicate. Stored alongside the
    *  doc and re-verified at evaluate. */
   predicateHash: string
-  /** Per-policy overrides of oracle thresholds; absent = use defaults.
-   *  Overrides may TIGHTEN only (never widen) - the interpreter rejects any per-policy
-   *  value looser than the wasm-level defaults at install. */
-  oracleParams?: {
-    /** Seconds; must be <= MAX_ORACLE_STALENESS_SECONDS (600). */
-    maxStalenessSeconds?: number
-    /** Basis points; must be <= MAX_ORACLE_DEVIATION_BPS (200). */
-    maxDeviationBps?: number
-  }
 }
 
 /** The versioned predicate AST (interpreter side). Tagged union. */
 export type PredicateNode =
   | { op: 'and'; children: PredicateNode[] }
-  | { op: 'or'; children: PredicateNode[] }
-  | { op: 'not'; child: PredicateNode }
   | { op: 'eq'; left: PredicateLeaf; right: PredicateLeaf }
-  | { op: 'lt' | 'lte' | 'gt' | 'gte'; left: PredicateLeaf; right: PredicateLeaf }
+  | { op: 'lte'; left: PredicateLeaf; right: PredicateLeaf }
   | {
       op: 'in'
       needle: PredicateLeaf
@@ -155,48 +150,18 @@ export type PredicateLeaf =
   // recorded ScVal type. A non-vec arg, missing element, missing field, or
   // type mismatch all DENY (fail-closed).
   | { kind: 'call_arg_field'; index: number; element: number; field: string }
-  // `call_arg_scaled(index, num, den)` evaluates to `args[index] * num / den`
-  // (truncating toward zero). The slippage-floor leaf: a swap policy
-  // expresses `call_arg[out] >= call_arg_scaled(in, num, den)` as "the
-  // minimum output must be at least this ratio of the input". `num`/`den`
-  // are decimal strings on i128 (mirrors `literal_i128`); the contract
-  // refuses `den == 0` and `num <= 0` / `den <= 0` at install.
-  | { kind: 'call_arg_scaled'; index: number; num: string; den: string }
-  // `call_sub_invocation[i]` is NOT in v1 grammar. OZ `Policy::enforce`
-  // receives one `Context`, not a sub-invocation tree; sub-invocations live under
-  // `InvokerContractAuthEntry::Contract(SubContractInvocation)`, not in the
-  // enforce Context. Scope is per-authorized-context; a v1.1 sub-invocation
-  // tree leaf is gated on the enforce-Context-shape spike result.
-  | { kind: 'amount'; token: string }
-  | { kind: 'window_spent'; token: string; windowSeconds: number }
-  | { kind: 'now' }
-  | { kind: 'valid_until' }
-  | { kind: 'invocation_count_in_window'; windowSecs: number }
-  | { kind: 'oracle_price'; asset: string } // Stellar Address (SAC address for SEP-41; XLM uses its network SAC)
-  // The right-hand side of an oracle comparison. It carries its own decimal
-  // basis because the contract cannot recover it: prices normalise to 9 dp, so
-  // a raw 14-dp threshold is ~10^5 too large and `price <= threshold` becomes
-  // trivially true. `value` is a decimal string on i128, like `literal_i128`.
-  | { kind: 'oracle_threshold'; value: string; decimals: number }
   // Literal leaves: bare ScVal on the wire (no selector-tuple wrapper). Right-hand side of
   // comparisons, elements of `in` haystacks, and operands to future arithmetic nodes.
   | { kind: 'literal_address'; value: string }
   | { kind: 'literal_i128'; value: string }
   | { kind: 'literal_symbol'; value: string }
   | { kind: 'literal_u32'; value: number }
-  | { kind: 'literal_u64'; value: string }
-  | { kind: 'literal_bytes'; value: string } // hex string; wrapped as ScVal::Bytes at encode time
   // Exact ordered vector of literals (e.g. a swap hop path). Encodes to a bare
   // ScVal::Vec with the caller's order preserved verbatim - the order IS the
   // semantic. An exact ordered sequence equality is expressed by `eq(selector,
   // literal_vec([...]))`. `in` is reserved for pure set membership (sorted).
   | { kind: 'literal_vec'; elements: PredicateLeaf[] }
 
-export interface OZPrimitiveConfig {
-  primitive: 'spending_limit' | 'simple_threshold' | 'weighted_threshold'
-  params: Record<string, unknown>
-}
-
 export interface ContractInvocation {
   contract: string
   fn: string
@@ -263,7 +228,6 @@ export type AmbiguityCode =
   | 'AMOUNT_BOUND_MISSING'
   | 'RECIPIENT_ALLOWLIST_EMPTY'
   | 'FREQUENCY_BOUND_MISSING'
-  | 'ORACLE_ASSET_UNKNOWN'
   | 'MULTIPLE_UNRELATED_TARGETS'
 
 /** Structured recording freshness. `overall` is the gate threshold (default 1.0); the

package/dist/adapters/interpreter/index.d.ts

@@ -1 +0,0 @@
-export { createInterpreterAdapter, type InterpreterAdapterConfig, ORACLE_DEFAULTS, PLACEHOLDER_INTERPRETER_ADDRESS, } from './adapter.ts';

package/dist/adapters/interpreter/index.js

@@ -1,2 +0,0 @@
-// src/adapters/interpreter/index.ts - re-export the interpreter-policy CustodyAdapter.
-export { createInterpreterAdapter, ORACLE_DEFAULTS, PLACEHOLDER_INTERPRETER_ADDRESS, } from "./adapter.js";

package/dist/adapters/oz/adapter.d.ts

@@ -1,20 +0,0 @@
-import type { CustodyAdapter } from '../../seams/types.ts';
-import type { Network } from '../../types.ts';
-/** OZ built-in policy contract instance addresses, per primitive. */
-export interface OzPrimitiveInstances {
-    spending_limit: string;
-    simple_threshold: string;
-    weighted_threshold: string;
-}
-/** Per-network config for the OZ adapter. */
-export interface OzAdapterConfig {
-    network: Network;
-    instances: OzPrimitiveInstances;
-}
-/** [VERIFY] NOT real deployed addresses. The OZ built-in policy instances are
- *  per-network deploy artifacts we do not have yet; install is a later phase.
- *  Injected so the adapter never invents a Stellar contract address. */
-export declare const PLACEHOLDER_OZ_INSTANCES: OzPrimitiveInstances;
-/** Week-1 OZ adapter config with placeholder instance addresses. */
-export declare function placeholderOzConfig(network: Network): OzAdapterConfig;
-export declare function createOzAdapter(config: OzAdapterConfig): CustodyAdapter;

package/dist/adapters/oz/adapter.js

@@ -1,295 +0,0 @@
-// src/adapters/oz/adapter.ts - the OZ Accounts CustodyAdapter.
-//
-// Compiles a PolicyIR to an OZ `ProposedPolicy` using OZ built-in policy
-// primitives. Only the constructs OZ can express natively are lowered:
-//   scope.contract            -> ContextRuleType.call_contract (else default)
-//   expiry.validUntilLedger   -> ContextRuleDraft.validUntilLedger
-//   window_spent(t,w) <= L    -> `spending_limit` primitive
-//   approval.threshold        -> `simple_threshold` / `weighted_threshold`
-// Anything needing a capability this backend lacks (oracle price, invocation
-// count, per-arg comparison/allowlist, guard, nested boolean predicate) is NOT
-// emitted: it is named in `uncovered` and `covered` is set false. Nothing is
-// silently dropped.
-//
-// OZ built-in policy instance addresses are per-network deploy artifacts we do
-// not have yet (install is a later phase). They are injected via config; week-1
-// ships a clearly-labelled [VERIFY] placeholder so nothing invents an address.
-import { OZ_LIMITS, SOROBAN_LIMITS } from "../../types.js";
-/** [VERIFY] NOT real deployed addresses. The OZ built-in policy instances are
- *  per-network deploy artifacts we do not have yet; install is a later phase.
- *  Injected so the adapter never invents a Stellar contract address. */
-export const PLACEHOLDER_OZ_INSTANCES = {
-    spending_limit: 'VERIFY-oz-spending-limit-instance-address',
-    simple_threshold: 'VERIFY-oz-simple-threshold-instance-address',
-    weighted_threshold: 'VERIFY-oz-weighted-threshold-instance-address',
-};
-/** Week-1 OZ adapter config with placeholder instance addresses. */
-export function placeholderOzConfig(network) {
-    return { network, instances: PLACEHOLDER_OZ_INSTANCES };
-}
-/** Parse confidence for a deterministic (non-decoded) input: full (1.0). A
- *  mandate needs no decoding, so the gate is not applicable. */
-const FULL_PARSE_CONFIDENCE = {
-    overall: 1,
-    knownContracts: [],
-    unknownContracts: [],
-    opaqueScVals: [],
-    thresholdUsed: 1,
-};
-const CAPABILITIES = {
-    supportsSpendWindow: true,
-    supportsThreshold: true,
-    supportsTimeExpiry: true,
-    supportsOraclePrice: false,
-    supportsInvocationCount: false,
-    supportsGeneralPredicate: false,
-};
-export function createOzAdapter(config) {
-    return {
-        name: 'oz-accounts',
-        mode: 'enforce',
-        capabilities: () => ({ ...CAPABILITIES }),
-        compile: (ir) => compile(ir, config),
-        simulate: () => simulateStub(),
-        export: (ir) => canonicalStringify(ir),
-    };
-}
-function compile(ir, config) {
-    const uncovered = [];
-    const firstRule = ir.rules[0];
-    if (!firstRule) {
-        return { covered: false, uncovered: ['empty PolicyIR (no rules to compile)'] };
-    }
-    if (ir.rules.length > 1) {
-        uncovered.push(`multi-rule PolicyIR: ${ir.rules.length - 1} rule(s) beyond the first are not compiled (a ProposedPolicy carries a single context rule in this slice)`);
-    }
-    const lowered = lowerRule(firstRule, config);
-    uncovered.push(...lowered.uncovered);
-    const result = { covered: uncovered.length === 0, uncovered };
-    if (!lowered.capExceeded) {
-        const proposed = {
-            contextRule: lowered.contextRule,
-            policyDocuments: [],
-            policyRefs: lowered.policyRefs,
-            parseConfidence: { ...FULL_PARSE_CONFIDENCE },
-            warnings: [],
-            ambiguities: [],
-        };
-        result.proposed = proposed;
-    }
-    return result;
-}
-function lowerRule(rule, config) {
-    const uncovered = [];
-    const policyRefs = [];
-    // scope -> context rule type. OZ scopes by contract (CallContract); a
-    // method-level restriction is flagged as not covered because CallContract
-    // alone permits other methods on the same contract (e.g. an unbounded approve
-    // alongside a capped transfer).
-    const contextRuleType = rule.scope.contract !== undefined
-        ? { kind: 'call_contract', contract: rule.scope.contract }
-        : { kind: 'default' };
-    if (rule.scope.method !== undefined && rule.scope.contract !== undefined) {
-        uncovered.push(`per-method scoping to \`${rule.scope.method}\` (OZ CallContract scopes by contract only; requires the interpreter predicate)`);
-    }
-    if (rule.scope.chainId !== undefined) {
-        uncovered.push(`chainId \`${rule.scope.chainId}\` not bindable by the Stellar OZ adapter (network is per-context, not per-rule)`);
-    }
-    if (rule.roles.length > 0) {
-        uncovered.push(`roles [${rule.roles.join(', ')}] dropped (role-to-signer mapping is a later phase; OZ signers carry addresses, not role names)`);
-    }
-    // expiry -> validUntilLedger. Unix-timestamp expiry cannot be expressed by an
-    // OZ context rule (it expires by ledger sequence), so flag it.
-    let validUntilLedger = null;
-    if (rule.expiry) {
-        if (rule.expiry.validUntilLedger !== undefined) {
-            validUntilLedger = rule.expiry.validUntilLedger;
-        }
-        else if (rule.expiry.validUntilUnixSeconds !== undefined) {
-            uncovered.push('time expiry given as a unix timestamp (OZ context rules expire by ledger sequence; supply expiry.validUntilLedger)');
-        }
-    }
-    // guard -> not covered (applicability predicates are not an OZ built-in).
-    if (rule.guard) {
-        uncovered.push(`guard: ${describeCondition(rule.guard)}`);
-    }
-    // constraints -> spending_limit where they match; else not covered. The OZ
-    // spending_limit takes `{ spending_limit: i128, period_ledgers: u32 }` and
-    // has NO token param: it only accepts a CallContract context rule
-    // (OnlyCallContractAllowed) and limits transfers of that context's contract,
-    // so the spent token must equal the scope contract, and the window is a
-    // ledger count (~5s/ledger), not seconds.
-    for (const c of rule.constraints) {
-        const spend = matchSpendingLimit(c);
-        if (!spend) {
-            uncovered.push(describeCondition(c));
-            continue;
-        }
-        if (contextRuleType.kind !== 'call_contract' || spend.token !== contextRuleType.contract) {
-            uncovered.push(`spending_limit on token ${spend.token} needs a CallContract context scoped to that token (OZ pins the limit to the context contract, not a token param)`);
-            continue;
-        }
-        policyRefs.push({
-            kind: 'oz_builtin',
-            primitive: {
-                primitive: 'spending_limit',
-                params: {
-                    spending_limit: spend.limit,
-                    period_ledgers: secondsToLedgers(spend.windowSeconds),
-                },
-            },
-            instanceAddress: config.instances.spending_limit,
-        });
-    }
-    // approval.threshold -> simple/weighted threshold primitive. A threshold < 1
-    // is not a real M-of-N gate (0 approvals authorises everything), so refuse to
-    // emit a no-op primitive and flag it as not covered.
-    if (rule.approval) {
-        if (!Number.isInteger(rule.approval.threshold) || rule.approval.threshold < 1) {
-            uncovered.push(`approval threshold ${rule.approval.threshold} is not a positive integer (a 0 or negative threshold is not an M-of-N gate)`);
-        }
-        else {
-            const weights = rule.approval.weights;
-            if (weights && Object.keys(weights).length > 0) {
-                policyRefs.push({
-                    kind: 'oz_builtin',
-                    primitive: {
-                        primitive: 'weighted_threshold',
-                        params: { threshold: rule.approval.threshold, weights },
-                    },
-                    instanceAddress: config.instances.weighted_threshold,
-                });
-            }
-            else {
-                policyRefs.push({
-                    kind: 'oz_builtin',
-                    primitive: {
-                        primitive: 'simple_threshold',
-                        params: { threshold: rule.approval.threshold },
-                    },
-                    instanceAddress: config.instances.simple_threshold,
-                });
-            }
-        }
-    }
-    const capExceeded = policyRefs.length > OZ_LIMITS.maxPoliciesPerRule;
-    if (capExceeded) {
-        uncovered.push(`policy count ${policyRefs.length} exceeds OZ maxPoliciesPerRule (${OZ_LIMITS.maxPoliciesPerRule})`);
-    }
-    const contextRule = {
-        contextRuleType,
-        name: contextRuleType.kind === 'call_contract'
-            ? `call_contract:${contextRuleType.contract}`
-            : 'default',
-        validUntilLedger,
-        signers: [],
-        policies: policyRefs,
-    };
-    return { contextRule, policyRefs, uncovered, capExceeded };
-}
-/** Convert a spend window in seconds to OZ `period_ledgers` (u32, >= 1).
- *  Stellar targets a ~5s ledger close time. */
-function secondsToLedgers(windowSeconds) {
-    return Math.max(1, Math.round(windowSeconds / SOROBAN_LIMITS.secondsPerLedger));
-}
-/** Match the `window_spent(token, window) <= limit` compare that lowers to the
- *  OZ `spending_limit` primitive. Only `lte` matches (the spend-cap semantic). */
-function matchSpendingLimit(c) {
-    if (c.op !== 'compare')
-        return null;
-    const { selector, operator, value } = c.compare;
-    if (selector.kind !== 'window_spent' || operator !== 'lte')
-        return null;
-    return { token: selector.token, limit: value, windowSeconds: selector.windowSeconds };
-}
-/** Human-readable descriptor for a construct the OZ built-in-primitive backend
- *  cannot express, used to populate `uncovered`. */
-function describeCondition(cond) {
-    switch (cond.op) {
-        case 'slippage_floor':
-            // OZ primitives bound a value against a constant; this bounds one call
-            // argument against another, which none of them can express.
-            return `slippage floor on arg[${cond.outArgIndex}] (OZ built-ins cannot bound one argument against another)`;
-        case 'in':
-            return `value allowlist on ${describeSelector(cond.selector)} (arg allowlist)`;
-        case 'eq_seq':
-            return `exact ordered sequence on ${describeSelector(cond.selector)} (OZ built-ins cannot express an exact vector)`;
-        case 'not':
-            return 'negated condition (predicate DSL)';
-        case 'and':
-        case 'or':
-            return `nested ${cond.op} condition (predicate DSL)`;
-        case 'compare': {
-            const s = cond.compare.selector;
-            switch (s.kind) {
-                case 'oracle_price':
-                    return `oracle price condition on ${s.asset} (oracle price not supported in week-1)`;
-                case 'invocation_count':
-                    return `invocation-count window (${s.windowSeconds}s) condition (not supported in week-1)`;
-                case 'window_spent':
-                    return `spend-window comparison with operator '${cond.compare.operator}' (only 'lte' lowers to spending_limit)`;
-                case 'amount':
-                    return `per-call amount comparison on ${s.token} (predicate DSL)`;
-                case 'arg':
-                    return `argument comparison on arg ${s.argIndex} (predicate DSL)`;
-                case 'arg_len':
-                    return `vec length comparison on arg ${s.argIndex} (predicate DSL)`;
-                case 'arg_field':
-                    return `map field comparison on arg ${s.argIndex}.${s.field} (predicate DSL)`;
-                case 'calldata':
-                    return 'EVM calldata comparison (predicate DSL)';
-                case 'value':
-                    return 'tx.value comparison (predicate DSL)';
-                case 'now':
-                case 'valid_until':
-                    return 'time comparison (predicate DSL)';
-            }
-        }
-    }
-}
-function describeSelector(s) {
-    switch (s.kind) {
-        case 'arg':
-            return `arg ${s.argIndex}`;
-        case 'arg_len':
-            return `arg_len(${s.argIndex})`;
-        case 'arg_field':
-            return `arg_field(${s.argIndex}, ${s.element}, ${s.field})`;
-        case 'amount':
-            return `amount(${s.token})`;
-        case 'window_spent':
-            return `window_spent(${s.token})`;
-        case 'oracle_price':
-            return `oracle_price(${s.asset})`;
-        case 'invocation_count':
-            return `invocation_count(${s.windowSeconds}s)`;
-        case 'calldata':
-            return `calldata[${s.offset}:${s.offset + s.length}]`;
-        default:
-            return s.kind;
-    }
-}
-function simulateStub() {
-    return {
-        backend: 'ts-model',
-        permitted: null,
-        evaluations: [],
-        notes: ['stub: real permit/deny semantics wiring is a later phase'],
-    };
-}
-/** Canonical JSON with recursively sorted object keys (stable across runs). */
-function canonicalStringify(value) {
-    return JSON.stringify(sortKeys(value));
-}
-function sortKeys(value) {
-    if (Array.isArray(value))
-        return value.map(sortKeys);
-    if (value && typeof value === 'object') {
-        const out = {};
-        for (const key of Object.keys(value).sort()) {
-            out[key] = sortKeys(value[key]);
-        }
-        return out;
-    }
-    return value;
-}

package/dist/adapters/oz/index.d.ts

@@ -1 +0,0 @@
-export { createOzAdapter, type OzAdapterConfig, type OzPrimitiveInstances, PLACEHOLDER_OZ_INSTANCES, placeholderOzConfig, } from './adapter.ts';

package/dist/adapters/oz/index.js

@@ -1,2 +0,0 @@
-// src/adapters/oz/index.ts - re-export the OZ Accounts CustodyAdapter.
-export { createOzAdapter, PLACEHOLDER_OZ_INSTANCES, placeholderOzConfig, } from "./adapter.js";

package/dist/codegen/compile-gate.d.ts

@@ -1,33 +0,0 @@
-export type CompileGateResult = {
-    code: 'COMPILE_OK';
-} | {
-    code: 'COMPILE_GATE_FAILED';
-    stderr: string;
-} | {
-    code: 'SKIPPED';
-    reason: string;
-};
-export interface CompileGateOpts {
-    /** Caller-controlled abort signal; aborting before toolchain probe resolves
-     *  the gate to `SKIPPED` rather than starting a cargo invocation. */
-    signal?: AbortSignal;
-    /** Override the `cargo` binary (mostly for tests). */
-    cargoBin?: string;
-    /** Override the target directory (mostly for tests). */
-    tempDir?: string;
-}
-/** Probe the host for the Rust toolchain the gate requires. We require BOTH
- *  `cargo` AND `stellar` (the Soroban CLI) because a real gate run invokes
- *  `stellar contract build`; absent either, the gate returns `SKIPPED`. */
-export declare function hasRustToolchain(): Promise<boolean>;
-/** Compile-check a Rust source string against the pinned Soroban SDK.
- *
- *  - Toolchain absent -> `{ code: 'SKIPPED', reason }` (NOT a failure).
- *  - Toolchain present, source compiles -> `{ code: 'COMPILE_OK' }`.
- *  - Toolchain present, source broken -> `{ code: 'COMPILE_GATE_FAILED', stderr }`.
- *
- *  The gate writes the source to a temporary crate and runs `cargo check`
- *  against it; the crate is cleaned up whether or not compilation succeeds.
- *  The caller is expected to surface `COMPILE_GATE_FAILED.stderr` to the
- *  user (the LLM agent) so the user can iterate. */
-export declare function compileCheck(rustSource: string, opts?: CompileGateOpts): Promise<CompileGateResult>;

package/dist/codegen/compile-gate.js

@@ -1,124 +0,0 @@
-// src/codegen/compile-gate.ts - toolchain-gated `cargo check` for the
-// codegen escape hatch.
-//
-// The escape hatch ships as the `policy-builder escape-hatch` CLI subcommand
-// (a later phase). This gate is its safety net, NOT the happy path. Property:
-// generated Rust compiles against the pinned OZ crate; broken source returns
-// `COMPILE_GATE_FAILED` with `stderr`; an absent toolchain returns `SKIPPED`
-// (does NOT fail - we cannot make build tools a hard runtime requirement for
-// a TypeScript package).
-import { spawn } from 'node:child_process';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-/** Probe the host for the Rust toolchain the gate requires. We require BOTH
- *  `cargo` AND `stellar` (the Soroban CLI) because a real gate run invokes
- *  `stellar contract build`; absent either, the gate returns `SKIPPED`. */
-export async function hasRustToolchain() {
-    const probe = await probeToolchain();
-    return probe.present;
-}
-async function probeToolchain() {
-    const cargo = await which('cargo');
-    if (!cargo)
-        return { present: false, reason: 'cargo not found on PATH' };
-    const stellar = await which('stellar');
-    if (!stellar)
-        return { present: false, reason: 'stellar not found on PATH' };
-    return { present: true, reason: `${cargo} + ${stellar}` };
-}
-async function which(bin) {
-    try {
-        const out = await runProcess('sh', ['-c', `command -v ${bin}`], { capture: true });
-        const path = out.stdout.trim();
-        return path.length > 0 ? path : null;
-    }
-    catch {
-        return null;
-    }
-}
-function runProcess(cmd, args, opts) {
-    return new Promise((resolve, reject) => {
-        if (opts.signal?.aborted) {
-            reject(new Error('aborted'));
-            return;
-        }
-        const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (b) => {
-            stdout += b.toString('utf8');
-        });
-        child.stderr.on('data', (b) => {
-            stderr += b.toString('utf8');
-        });
-        const onAbort = () => {
-            child.kill('SIGTERM');
-            reject(new Error('aborted'));
-        };
-        opts.signal?.addEventListener('abort', onAbort, { once: true });
-        child.on('error', (e) => {
-            opts.signal?.removeEventListener('abort', onAbort);
-            reject(e);
-        });
-        child.on('close', (code) => {
-            opts.signal?.removeEventListener('abort', onAbort);
-            resolve({ stdout, stderr, code: code ?? -1 });
-        });
-    });
-}
-const CARGO_MANIFEST = `[package]
-name = "escape-hatch-gate"
-version = "0.0.0"
-edition = "2021"
-publish = false
-
-[lib]
-crate-type = ["cdylib"]
-# The gate writes the source beside the manifest rather than under src/, so
-# the path is stated. Without it cargo looks for src/lib.rs and fails to
-# parse the manifest before it ever compiles anything, which reads as a
-# broken generator rather than a broken scaffold.
-path = "lib.rs"
-
-[dependencies]
-soroban-sdk = "22"
-
-[workspace]
-`;
-/** Compile-check a Rust source string against the pinned Soroban SDK.
- *
- *  - Toolchain absent -> `{ code: 'SKIPPED', reason }` (NOT a failure).
- *  - Toolchain present, source compiles -> `{ code: 'COMPILE_OK' }`.
- *  - Toolchain present, source broken -> `{ code: 'COMPILE_GATE_FAILED', stderr }`.
- *
- *  The gate writes the source to a temporary crate and runs `cargo check`
- *  against it; the crate is cleaned up whether or not compilation succeeds.
- *  The caller is expected to surface `COMPILE_GATE_FAILED.stderr` to the
- *  user (the LLM agent) so the user can iterate. */
-export async function compileCheck(rustSource, opts = {}) {
-    if (opts.signal?.aborted) {
-        return { code: 'SKIPPED', reason: 'aborted before probe' };
-    }
-    const probe = await probeToolchain();
-    if (!probe.present) {
-        return { code: 'SKIPPED', reason: probe.reason };
-    }
-    let dir = null;
-    try {
-        dir = await mkdtemp(join(opts.tempDir ?? tmpdir(), 'codegen-gate-'));
-        await writeFile(join(dir, 'Cargo.toml'), CARGO_MANIFEST);
-        await writeFile(join(dir, 'lib.rs'), rustSource);
-        const runOpts = opts.signal ? { signal: opts.signal } : {};
-        const result = await runProcess(opts.cargoBin ?? 'cargo', ['check', '--quiet', '--offline', '--manifest-path', join(dir, 'Cargo.toml')], runOpts).catch((e) => ({ stdout: '', stderr: e.message, code: -1 }));
-        if (result.code === 0) {
-            return { code: 'COMPILE_OK' };
-        }
-        return { code: 'COMPILE_GATE_FAILED', stderr: result.stderr || result.stdout };
-    }
-    finally {
-        if (dir) {
-            await rm(dir, { recursive: true, force: true }).catch(() => { });
-        }
-    }
-}

package/dist/codegen/index.d.ts

@@ -1,2 +0,0 @@
-export { type CompileGateOpts, type CompileGateResult, compileCheck, hasRustToolchain, } from './compile-gate.ts';
-export { type EscapeHatchSpec, generateRust, } from './template.ts';

package/dist/codegen/index.js

@@ -1,8 +0,0 @@
-// src/codegen/index.ts - re-export the codegen escape-hatch surface.
-//
-// The escape hatch is OUT of the audited happy path: the synthesiser never
-// calls `generateRust` itself; the CLI subcommand (a later phase) is the only
-// entry point. Keeping the surface in one file makes that boundary visible
-// in import statements.
-export { compileCheck, hasRustToolchain, } from "./compile-gate.js";
-export { generateRust, } from "./template.js";

package/dist/codegen/template.d.ts

@@ -1,18 +0,0 @@
-/** A small typed description of one uncovered constraint the v1 DSL refused
- *  to express. The synthesiser surfaces these from `CompileResult.uncovered`
- *  and the codegen escape hatch wraps them into a hand-auditable skeleton. */
-export interface EscapeHatchSpec {
-    /** Address of the policy contract the skeleton is generated for. */
-    contract: string;
-    /** The trait method the predicate lives inside (default: 'enforce'). */
-    fnName?: string;
-    /** Human-readable description of each construct the DSL could not cover. */
-    uncovered: string[];
-}
-/** Generate a deterministic OZ `Policy` skeleton for an uncovered constraint.
- *
- *  The skeleton is NOT a finished policy; the user fills in the predicate
- *  logic in the marked TODO(user) holes and audits the result themselves.
- *
- *  Same `(spec, name)` always produces byte-identical output. */
-export declare function generateRust(spec: EscapeHatchSpec, name: string): string;