@crediolabs/policy-synth 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @crediolabs/policy-synth
 
-Off-chain synthesis core for the OctoGate policy layer on Stellar. It turns a
+Off-chain synthesis core for the OZ Policy Builder on Stellar. It turns a
 transaction you recorded, or a mandate you can state in one sentence, into the
 minimal on-chain policy that permits exactly that flow, then verifies,
 simulates, and packages it for installation on an
@@ -8,7 +8,7 @@ simulates, and packages it for installation on an
 
 The on-chain half is the `policy-interpreter` Soroban contract, which lives in
 the same repository:
-[untangledfinance/octogate](https://github.com/untangledfinance/octogate).
+[untangledfinance/oz-policy-builder](https://github.com/untangledfinance/oz-policy-builder).
 
 ## Install
 
@@ -55,10 +55,10 @@ Nothing in this package holds key material. Install and revoke return
 The synthesiser is the convenience layer; enforcement lives on chain in the
 policy interpreter, whose deployed addresses and wasm sha256 are pinned in
 `src/run/schemas.ts` and checked against the live network on install. The
-[architecture document](https://github.com/untangledfinance/octogate/blob/main/docs/architecture.md)
+[architecture document](https://github.com/untangledfinance/oz-policy-builder/blob/main/docs/architecture.md)
 is specific about what is and is not enforced; the audit status of the
 contracts is stated in the
-[repository README](https://github.com/untangledfinance/octogate#readme).
+[repository README](https://github.com/untangledfinance/oz-policy-builder#readme).
 
 ## Related packages
 

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

@@ -1,15 +1,8 @@
-import type { IRPolicyRule } from '../../ir/types.ts';
-import type { CustodyAdapter } from '../../seams/types.ts';
-import type { Network, PredicateNode } from '../../types.ts';
+import type { ComposedRule } from '../../synth/compose-from-recording.ts';
+import { type Network, type PredicateNode, type ProposedPolicy } from '../../types.ts';
 /** [VERIFY] NOT a real deployed address. The interpreter is a per-network
  *  deploy artifact we do not have yet; install is a later phase. */
 export declare const PLACEHOLDER_INTERPRETER_ADDRESS = "VERIFY-interpreter-address";
-/** Wasm-level oracle defaults (mirrors the interpreter's `OracleParams`).
- *  Per-policy overrides may TIGHTEN only - they may never exceed these. */
-export declare const ORACLE_DEFAULTS: {
-    readonly maxStalenessSeconds: 600;
-    readonly maxDeviationBps: 200;
-};
 export interface InterpreterAdapterConfig {
     network: Network;
     /** Per-rule install nonce (first install = 1; replay-protected). */
@@ -18,20 +11,21 @@ export interface InterpreterAdapterConfig {
      *  by the self-call gate: any `in`-allowlist containing this address is
      *  rejected as `SCOPE_SELF_CALL`. */
     smartAccountAddress: string;
-    /** Optional per-policy oracle overrides. Must TIGHTEN vs ORACLE_DEFAULTS
-     *  (i.e. <= each default). A widening value throws ORACLE_PARAMS_OUT_OF_RANGE
-     *  at compile time. */
-    oracleParams?: {
-        maxStalenessSeconds?: number;
-        maxDeviationBps?: number;
-    };
 }
-export declare function createInterpreterAdapter(config: InterpreterAdapterConfig): CustodyAdapter;
-/** Lower a single IR rule to the canonical pre-encoding `PredicateNode`. The
- *  orchestrator uses this to wire the self-verify + minimise pipeline: after
- *  `compile(ir)` succeeds it re-derives the PredicateNode via this helper to
- *  drive `minimize` and `runHarness` on the SAME shape the encoder saw. Pure
- *  and deterministic: same `rule + config` -> byte-identical PredicateNode.
- *  The `uncovered` list is NOT re-derived - callers needing it must use
- *  `compile(ir)`. */
-export declare function lowerRuleToPredicate(rule: IRPolicyRule, config: InterpreterAdapterConfig): PredicateNode;
+/** The result of compiling a PolicyIR for this 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 installable policy, assembled when a rule lowered. */
+    proposed?: ProposedPolicy;
+}
+/** Lower a single rule to the canonical pre-encoding `PredicateNode`. The
+ *  orchestrator re-derives the PredicateNode through this helper so it holds the
+ *  SAME shape the encoder saw. Pure and deterministic: same `rule + config` ->
+ *  byte-identical PredicateNode. The `uncovered` list is NOT re-derived -
+ *  callers needing it must use `compileInterpreterPolicy(rule, config)`. */
+export declare function lowerRuleToPredicate(rule: ComposedRule, config: InterpreterAdapterConfig): PredicateNode;
+/** Compile a composed rule to an installable interpreter policy. */
+export declare function compileInterpreterPolicy(rule: ComposedRule, config: InterpreterAdapterConfig): CompileResult;