@crediolabs/policy-synth 0.3.0 → 0.3.1

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;

package/dist/codegen/template.js

@@ -1,148 +0,0 @@
-// src/codegen/template.ts - deterministic Rust source generator for the OZ
-// `Policy` escape-hatch skeleton.
-//
-// SUPERSEDED. The architecture this belongs to no longer exists. A deployed
-// policy involves exactly two contracts, the OZ smart account and one
-// immutable interpreter, and the synthesiser emits policy DATA rather than
-// code. Nothing on the synthesis path reaches this module, and no install can
-// produce a contract from it. When a constraint falls outside the grammar the
-// answer is to version the synthesiser and the interpreter together, not to
-// put unaudited Rust on chain per policy.
-//
-// Deleting it is a decision nobody has taken yet, not a dependency question.
-// `compile-gate.ts` takes a Rust string and knows nothing about this module,
-// and its tests compile a hardcoded fixture, so the gate keeps working either
-// way. What deleting this would remove is the only in-repo producer of policy
-// Rust for the gate to check. Do not read its presence as the product
-// generating contracts, and do not wire it into the synthesis path.
-//
-// What follows describes the abandoned design.
-//
-// This is the LAST-RESORT tool for constraints the v1 DSL cannot express. It
-// lives OUT of the audited happy-path surface; the synthesiser never emits it
-// automatically. It mirrors Zodiac Roles' `Custom` operator: a hand-written
-// (here: scaffolded) policy the operator assumes responsibility for.
-//
-// The skeleton carries five storage invariants the user MUST preserve when
-// filling in the predicate logic:
-//   1. `smart_account.require_auth()` is invoked INSIDE `enforce`.
-//   2. Storage is keyed by the composite `(smart_account, rule_id)`.
-//   3. Chain reads use `unwrap_or_default()` so a missing key is a permitted
-//      default, not a panic.
-//   4. Storage is `persistent()` (NOT `instance()`) so the policy survives
-//      contract instance lifecycle changes.
-//   5. `uninstall` removes the stored state.
-//
-// Determinism: same `(spec, name)` -> byte-identical output. No clock, no RNG,
-// no environment reads.
-/** Format a name for use as a Rust identifier. The input is constrained by
- *  the caller (a kebab-case policy name + alphanumeric addresses); this is a
- *  belt-and-braces sanitiser that maps anything non-identifier to '_'. */
-function asRustIdent(s) {
-    let out = '';
-    for (let i = 0; i < s.length; i++) {
-        const ch = s.charCodeAt(i);
-        const ok = (ch >= 48 && ch <= 57) || // 0-9
-            (ch >= 65 && ch <= 90) || // A-Z
-            (ch >= 97 && ch <= 122) || // a-z
-            ch === 95; // _
-        out += ok ? s[i] : '_';
-    }
-    // Identifiers may not start with a digit.
-    if (out.length > 0 && out.charCodeAt(0) >= 48 && out.charCodeAt(0) <= 57) {
-        out = `_${out}`;
-    }
-    return out || 'policy';
-}
-/** Render the `uncovered` list as a `//` comment block (one line per item). */
-function renderUncovered(uncovered) {
-    if (uncovered.length === 0) {
-        return '    // (no specific uncovered constructs reported)';
-    }
-    return uncovered.map((line) => `    // - ${line}`).join('\n');
-}
-/** 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 function generateRust(spec, name) {
-    const _contract = spec.contract;
-    const _fnName = spec.fnName ?? 'enforce';
-    const structName = asRustIdent(name);
-    const _dataKeyName = `${asRustIdent(name)}_data`;
-    const uncoveredBlock = renderUncovered(spec.uncovered);
-    return `// Auto-generated by the OZ Policy Builder codegen escape hatch.
-// THIS OUTPUT IS THE USER'S TO COMPLETE AND AUDIT.
-// The synthesiser never emits it on the happy path; reach for it only when
-// a constraint cannot be expressed in the v1 DSL grammar (same shape as
-// Zodiac Roles' \`Custom\` operator).
-
-#![no_std]
-
-use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, Vec};
-
-#[contracttype]
-pub enum DataKey {
-    /// Composite key \`(smart_account, rule_id)\` so multiple policies on
-    /// one smart account coexist without collision.
-    State(Address, u32),
-}
-
-#[contract]
-pub struct ${structName};
-
-#[contractimpl]
-impl ${structName} {
-    pub fn install(e: &Env, smart_account: Address, rule_id: u32) {
-        // TODO(user): initialise policy state for this (smart_account, rule_id).
-        // The skeleton leaves the stored value empty; the predicate body
-        // (in \`enforce\`) decides what to read.
-        e.storage().persistent().set(
-            &DataKey::State(smart_account.clone(), rule_id),
-            &(),
-        );
-    }
-
-    pub fn enforce(
-        e: &Env,
-        smart_account: Address,
-        rule_id: u32,
-        _signers: Vec<Address>,
-    ) {
-        // Invariant 1: authorise the smart account BEFORE any state read or
-        // predicate evaluation. Removing this call opens the policy to
-        // impersonation by any caller with a valid rule_id.
-        smart_account.require_auth();
-
-        // Invariant 2 + 4: read stored state through the composite key on
-        // \`persistent()\` storage. \`unwrap_or_default()\` (invariant 3)
-        // makes an empty key a permitted default rather than a panic.
-        let _state: () = e
-            .storage()
-            .persistent()
-            .get(&DataKey::State(smart_account.clone(), rule_id))
-            .unwrap_or_default();
-
-        // --- uncovered constraints the v1 DSL refused to express ---
-${uncoveredBlock}
-
-        // TODO(user): replace the placeholder below with the real predicate
-        // body. The recorded flow's \`(contract, fn_name, args)\` is the
-        // single authorised call \`Policy::enforce\` receives; match against
-        // \`e\` here.
-        let _ = (_state, &e);
-    }
-
-    pub fn uninstall(e: &Env, smart_account: Address, rule_id: u32) {
-        // Invariant 5: \`uninstall\` removes the stored state so a subsequent
-        // install starts from a clean slate (and the nonce returns to its
-        // post-uninstall value).
-        e.storage()
-            .persistent()
-            .remove(&DataKey::State(smart_account, rule_id));
-    }
-}
-`;
-}

package/dist/ir/index.d.ts

@@ -1 +0,0 @@
-export type { IRCompare, IRCompOp, IRCondition, IRLogic, IRPolicyRule, IRScalarType, IRSelector, PolicyIR, } from './types.ts';

package/dist/ir/index.js

@@ -1,2 +0,0 @@
-// src/ir/index.ts - re-export the PolicyIR ("Policy Tree") types.
-export {};

package/dist/ir/types.d.ts

@@ -1,71 +0,0 @@
-/** Comparison operator. Mirrors NEAR-V2 `CompOp`. */
-export type IRCompOp = 'eq' | 'lte';
-/** Boolean combinator. Mirrors NEAR-V2 `LogicOp`. */
-export type IRLogic = 'and';
-/** Scalar value type. The subset the predicate grammar has a literal for. */
-export type IRScalarType = 'address' | 'i128' | 'u32' | 'symbol';
-/** WHERE in the authorized call a value is read. NEAR-V2 selectors first, OZ
- *  extensions after (an adapter that cannot express an extension flags it). */
-export type IRSelector = {
-    kind: 'arg';
-    argIndex: number;
-    scalarType: IRScalarType;
-} | {
-    kind: 'arg_len';
-    argIndex: number;
-} | {
-    kind: 'arg_field';
-    argIndex: number;
-    element: number;
-    field: string;
-    scalarType: IRScalarType;
-};
-/** A single comparison leaf. `value` is a decimal/hex string (i128-safe;
- *  never a JS number). */
-export interface IRCompare {
-    selector: IRSelector;
-    operator: IRCompOp;
-    value: string;
-}
-/** Condition tree. NEAR-V2 guard/constraint are flat And/Or; the IR allows
- *  nesting + `not` + `in` + `eq_seq` so the same IR can later lower to the OZ
- *  predicate DSL. Week-1 adapters only lower the flat supported subset and flag
- *  the rest. */
-export type IRCondition = {
-    op: 'and';
-    children: IRCondition[];
-} | {
-    op: 'compare';
-    compare: IRCompare;
-} | {
-    op: 'in';
-    selector: IRSelector;
-    values: string[];
-}
-/** Exact ordered sequence equality. The IR-level selector value MUST EQUAL
- *  `values` as an ORDERED sequence (e.g. a swap hop `path`). `in` is pure
- *  set membership and cannot express order; `eq_seq` is the construct that
- *  does. Adapters that cannot express an exact ordered vector (OZ built-ins)
- *  flag this as `uncovered` rather than silently dropping it. */
- | {
-    op: 'eq_seq';
-    selector: IRSelector;
-    values: string[];
-};
-export interface IRPolicyRule {
-    /** NEAR-V2 scope filter; each field optional (absent = wildcard). */
-    scope: {
-        contract?: string;
-        method?: string;
-    };
-    /** NEAR-V2 constraint (AND; reject the transaction when any fails). */
-    constraints: IRCondition[];
-    /** OZ context-rule expiry, by ledger sequence - the only clock the OZ
-     *  account model exposes to a rule. */
-    expiry?: {
-        validUntilLedger?: number;
-    };
-}
-export interface PolicyIR {
-    rules: IRPolicyRule[];
-}

package/dist/ir/types.js

@@ -1,9 +0,0 @@
-// src/ir/types.ts - the PolicyIR ("Policy Tree").
-//
-// `PolicyIR` is the custody-agnostic "Policy Tree" hub (the diagram's Policy
-// Tree) that every CustodyAdapter compiles FROM. It generalizes the NEAR-V2
-// policy schema (roles / scope filter / guard / constraint / comparison leaves /
-// default behaviour) into one chain-neutral shape and extends it with the
-// single IR can serve every backend. NEAR-V2 has no stateful spend window,
-// below and are only lowered by adapters that declare support for them.
-export {};

package/dist/mandate/index.d.ts

@@ -1,2 +0,0 @@
-export { mandateToPolicyIR } from './to-ir.ts';
-export type { MandateSpec } from './types.ts';

package/dist/mandate/index.js

@@ -1,2 +0,0 @@
-// src/mandate/index.ts - re-export the Mandate source.
-export { mandateToPolicyIR } from "./to-ir.js";

package/dist/mandate/to-ir.d.ts

@@ -1,3 +0,0 @@
-import type { PolicyIR } from '../ir/types.ts';
-import type { MandateSpec } from './types.ts';
-export declare function mandateToPolicyIR(spec: MandateSpec): PolicyIR;

package/dist/mandate/to-ir.js

@@ -1,60 +0,0 @@
-// src/mandate/to-ir.ts - deterministic lowering of a MandateSpec to a PolicyIR.
-//
-// `mandateToPolicyIR` is pure and total: the same spec always lowers to a
-// byte-identical PolicyIR. No decoding, no inference, no clock. Each mandate
-// field maps to exactly one IR construct:
-//   contract/method  -> rule.scope
-//   spendingLimit    -> a `window_spent(token,window) <= limit` compare
-//   approvalThreshold-> rule.approval.threshold
-//   recipients       -> an `in` condition on the recipient arg (flagged as not
-//                       covered by the OZ adapter; that is expected)
-//   expiry           -> rule.expiry
-// The top-level default is `deny_all` (OZ context rules are deny-by-default).
-/** Arg index the recipient allowlist constrains. Pinned to the SEP-41
- *  `transfer(from, to, amount)` convention where `to` is arg 1. This condition
- *  is flagged as not covered by the OZ adapter (no built-in primitive expresses
- *  an arg allowlist), so the index only needs to be deterministic in week-1. */
-const RECIPIENT_ARG_INDEX = 1;
-export function mandateToPolicyIR(spec) {
-    const scope = { contract: spec.contract };
-    if (spec.method !== undefined)
-        scope.method = spec.method;
-    const constraints = [];
-    if (spec.spendingLimit) {
-        constraints.push({
-            op: 'compare',
-            compare: {
-                selector: {
-                    kind: 'window_spent',
-                    token: spec.spendingLimit.token,
-                    windowSeconds: spec.spendingLimit.windowSeconds,
-                },
-                operator: 'lte',
-                value: spec.spendingLimit.limit,
-            },
-        });
-    }
-    if (spec.recipients && spec.recipients.length > 0) {
-        const selector = {
-            kind: 'arg',
-            argIndex: RECIPIENT_ARG_INDEX,
-            scalarType: 'address',
-        };
-        constraints.push({ op: 'in', selector, values: [...spec.recipients] });
-    }
-    const rule = { roles: [], scope, constraints };
-    if (spec.approvalThreshold !== undefined) {
-        rule.approval = { kind: 'threshold', threshold: spec.approvalThreshold };
-    }
-    if (spec.expiry) {
-        const expiry = {};
-        if (spec.expiry.validUntilLedger !== undefined) {
-            expiry.validUntilLedger = spec.expiry.validUntilLedger;
-        }
-        if (spec.expiry.validUntilUnixSeconds !== undefined) {
-            expiry.validUntilUnixSeconds = spec.expiry.validUntilUnixSeconds;
-        }
-        rule.expiry = expiry;
-    }
-    return { chain: spec.chain, defaultBehavior: 'deny_all', rules: [rule] };
-}

package/dist/mandate/types.d.ts

@@ -1,20 +0,0 @@
-export interface MandateSpec {
-    chain: 'stellar';
-    contract: string;
-    method?: string;
-    /** -> OZ `spending_limit` primitive. `limit` is an i128 decimal string. */
-    spendingLimit?: {
-        token: string;
-        limit: string;
-        windowSeconds: number;
-    };
-    /** -> OZ `simple_threshold` / `weighted_threshold` primitive. */
-    approvalThreshold?: number;
-    /** Recipient allowlist -> an `in` arg condition (not covered by an OZ built-in). */
-    recipients?: string[];
-    /** -> OZ context-rule expiry. */
-    expiry?: {
-        validUntilLedger?: number;
-        validUntilUnixSeconds?: number;
-    };
-}

package/dist/mandate/types.js

@@ -1,8 +0,0 @@
-// src/mandate/types.ts - the deterministic Mandate source.
-//
-// A MandateSpec is a declarative policy statement: "this account may call this
-// contract, spending at most L per window, requiring M approvals, to these
-// recipients, until this expiry". It carries NO transaction to decode, NO
-// parseConfidence, and NO inference - it lowers deterministically to a
-// PolicyIR. It is the clean end-to-end demo path, co-equal with the recorder.
-export {};

package/dist/seams/index.d.ts

@@ -1 +0,0 @@
-export type { ChainDecoder, CompileResult, CustodyAdapter, CustodyCapabilities, CustodyMode, PolicySource, SimulationResult, } from './types.ts';

package/dist/seams/index.js

@@ -1,2 +0,0 @@
-// src/seams/index.ts - re-export the three custody-seam contracts.
-export {};

package/dist/seams/types.d.ts

@@ -1,64 +0,0 @@
-import type { ToolResponse } from '../errors.ts';
-import type { PolicyIR } from '../ir/types.ts';
-import type { Network, ProposedPolicy, RecordedTransaction, ScVal } from '../types.ts';
-/** INPUT: something that produces a normalized RecordedTransaction. */
-export interface PolicySource {
-    readonly name: string;
-    capture(input: {
-        hash?: string;
-        xdr?: string;
-        network: Network;
-    }): Promise<ToolResponse<RecordedTransaction>>;
-}
-/** DECODE: chain-specific call data -> the normalized facts the synth reasons
- *  over. */
-export interface ChainDecoder {
-    readonly chain: 'stellar' | 'evm';
-    decodeInvocation(tx: RecordedTransaction): {
-        contract: string;
-        method: string;
-        args: ScVal[];
-    };
-}
-/** OZ = enforce; `log_only` is reserved for shadow mode (out of scope). */
-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 {
-    supportsSpendWindow: boolean;
-    supportsTimeExpiry: boolean;
-    supportsThreshold: boolean;
-    supportsGeneralPredicate: boolean;
-}
-/** The result of compiling a PolicyIR for one backend. */
-export interface CompileResult {
-    /** false => some IR construct this backend cannot express (see `uncovered`). */
-    covered: boolean;
-    /** Human-readable list of unsupported constructs. */
-    uncovered: string[];
-    /** The backend-native installable policy, assembled when a rule lowered. */
-    proposed?: ProposedPolicy;
-}
-/** Result of a simulate() dry-run. `ts-model` is the off-chain TS evaluator.
- *  Real permit/deny semantics wiring is a later phase; week-1 returns a
- *  clearly-marked stub (empty `evaluations`, `permitted: null`). */
-export interface SimulationResult {
-    backend: 'ts-model';
-    /** Whether the permit tx would be allowed; null until real semantics land. */
-    permitted: boolean | null;
-    /** Per-construct evaluation trace; empty placeholder in this slice. */
-    evaluations: unknown[];
-    /** Diagnostics; marks the stub explicitly. */
-    notes: string[];
-}
-/** OUTPUT: compile a PolicyIR to a backend-specific installable policy. */
-export interface CustodyAdapter {
-    readonly name: string;
-    readonly mode: CustodyMode;
-    capabilities(): CustodyCapabilities;
-    compile(ir: PolicyIR): CompileResult;
-    /** Phase-03 wiring; a clearly-marked stub in week-1. */
-    simulate(ir: PolicyIR, permitTx: RecordedTransaction): SimulationResult;
-    /** Canonical JSON of the IR (portability / audit). */
-    export(ir: PolicyIR): string;
-}

package/dist/seams/types.js

@@ -1,11 +0,0 @@
-// src/seams/types.ts - the three custody seams (contracts, not implementations).
-//
-// The synthesizer is decoupled from its edges by three seams:
-//   - PolicySource  (INPUT):  produces a normalized RecordedTransaction. The
-//                             recorder is the reference source; a MandateSpec
-//                             lowering is a second, deterministic source.
-//   - ChainDecoder  (DECODE): chain-specific call data -> normalized facts.
-//   - CustodyAdapter (OUTPUT): compile a PolicyIR to a backend-native policy +
-//                             verify/export it (OZ is the first adapter).
-// These are INTERFACES only. Implementations live in their own modules.
-export {};

package/dist/synth/deny-cases.d.ts

@@ -1,28 +0,0 @@
-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[];
-}
-declare const OVERPERMISSIVE_DIMENSIONS: readonly ["argument_reorder"];
-export { OVERPERMISSIVE_DIMENSIONS };
-/** 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;