@intutic/shared-types 1.10.0 → 2.0.0

package/dist/providers.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Multi-provider credential registry (LLD #67, multi-provider key wizard).
+ *
+ * `services/control-plane/src/routes/providerCredentials.ts` originally
+ * hardcoded exactly 3 providers (anthropic/openai/gemini), each a single
+ * bearer API key — sufficient for those three, but LiteLLM's real provider
+ * surface includes providers needing MULTIPLE credential fields (Azure
+ * OpenAI: endpoint + deployment + key; Bedrock: AWS region + access key +
+ * secret; Vertex AI: a service-account JSON blob). This registry is a
+ * data-driven description of a provider's credential shape, so adding a
+ * new provider's *field layout* is a data change here, not new code in
+ * every place that touches credentials.
+ *
+ * Deliberately NOT exhaustive — LiteLLM supports 100+ providers. This is a
+ * representative slice spanning the shapes that actually differ (single
+ * key, multi-field cloud credential, self-hosted endpoint, structured
+ * blob), chosen so the registry's own shape is proven out before claiming
+ * to cover the full LiteLLM catalog. Adding another provider that fits one
+ * of these shapes is adding one entry, not new plumbing.
+ *
+ * `routingLive: true` means `packages/proxy` actually forwards requests to
+ * this provider today (`fetch_provider_credential` in `proxy.rs` knows its
+ * field name). `routingLive: false` means the credential can be
+ * pre-provisioned here, but nothing in the proxy calls it yet — routing
+ * support is separate, real per-provider engineering (a new `Provider`
+ * enum variant, `get_model_provider`, pricing in `pricing.rs`), not a
+ * config change. The dashboard wizard must say so, not imply the key is
+ * live the moment it's saved.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_REGISTRY = exports.LIVE_ROUTING_PROVIDER_IDS = void 0;
+exports.getProviderDefinition = getProviderDefinition;
+exports.isKnownProviderId = isKnownProviderId;
+exports.inferProviderForModel = inferProviderForModel;
+/**
+ * The 3 providers this system supported before this registry existed —
+ * their storage format (`{provider}_api_key`, a flat string field) is
+ * unchanged here, matching what `packages/proxy/src/proxy.rs`'s
+ * `fetch_provider_credential` has always read for them.
+ *
+ * NOT the same question as a provider's `routingLive` flag. This constant
+ * decides *storage shape* (flat field vs. `{provider}_config` JSON blob);
+ * `routingLive` decides whether the proxy currently forwards requests to a
+ * provider at all. They agreed for exactly these 3 while this registry only
+ * covered its original scope, but multi-provider wizard phase 3 added real
+ * proxy routing for Mistral and OpenRouter *without* changing their storage
+ * format — `fetch_provider_credential` reads the JSON blob for both, never
+ * the flat field, so they stay off this list even though `routingLive` is
+ * now `true` for them. Adding a provider here changes what Valkey field
+ * `services/control-plane/src/routes/providerCredentials.ts` writes to —
+ * only do it alongside the matching proxy-side flat-field read, never for
+ * the "is this provider live" reason alone.
+ */
+exports.LIVE_ROUTING_PROVIDER_IDS = ['anthropic', 'openai', 'gemini'];
+exports.PROVIDER_REGISTRY = [
+    {
+        id: 'anthropic',
+        displayName: 'Anthropic',
+        docsUrl: 'https://console.anthropic.com/settings/keys',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true, placeholder: 'sk-ant-...' }],
+        routingLive: true,
+    },
+    {
+        id: 'openai',
+        displayName: 'OpenAI',
+        docsUrl: 'https://platform.openai.com/api-keys',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true, placeholder: 'sk-...' }],
+        routingLive: true,
+    },
+    {
+        id: 'gemini',
+        displayName: 'Google Gemini',
+        docsUrl: 'https://aistudio.google.com/app/apikey',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true }],
+        routingLive: true,
+    },
+    {
+        id: 'azure_openai',
+        displayName: 'Azure OpenAI',
+        docsUrl: 'https://learn.microsoft.com/azure/ai-services/openai/how-to/create-resource',
+        fields: [
+            { key: 'apiKey', label: 'API Key', type: 'password', required: true },
+            { key: 'endpoint', label: 'Resource Endpoint', type: 'text', required: true, placeholder: 'https://your-resource.openai.azure.com' },
+            { key: 'deploymentName', label: 'Deployment Name', type: 'text', required: true },
+        ],
+        routingLive: false,
+    },
+    {
+        id: 'bedrock',
+        displayName: 'AWS Bedrock',
+        docsUrl: 'https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html',
+        fields: [
+            { key: 'awsAccessKeyId', label: 'AWS Access Key ID', type: 'password', required: true },
+            { key: 'awsSecretAccessKey', label: 'AWS Secret Access Key', type: 'password', required: true },
+            { key: 'awsRegion', label: 'AWS Region', type: 'text', required: true, placeholder: 'us-east-1' },
+        ],
+        routingLive: false,
+    },
+    {
+        id: 'vertex_ai',
+        displayName: 'Google Vertex AI',
+        docsUrl: 'https://cloud.google.com/vertex-ai/docs/authentication',
+        fields: [
+            { key: 'projectId', label: 'GCP Project ID', type: 'text', required: true },
+            { key: 'serviceAccountJson', label: 'Service Account JSON', type: 'textarea', required: true, helpText: 'The full JSON key file contents for a service account with Vertex AI access.' },
+        ],
+        routingLive: false,
+    },
+    {
+        id: 'cohere',
+        displayName: 'Cohere',
+        docsUrl: 'https://dashboard.cohere.com/api-keys',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true }],
+        routingLive: false,
+    },
+    {
+        id: 'mistral',
+        displayName: 'Mistral AI',
+        docsUrl: 'https://console.mistral.ai/api-keys',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true }],
+        routingLive: true,
+    },
+    {
+        id: 'openrouter',
+        displayName: 'OpenRouter',
+        docsUrl: 'https://openrouter.ai/keys',
+        fields: [{ key: 'apiKey', label: 'API Key', type: 'password', required: true }],
+        routingLive: true,
+    },
+    {
+        id: 'ollama',
+        displayName: 'Ollama (self-hosted)',
+        docsUrl: 'https://github.com/ollama/ollama/blob/main/docs/api.md',
+        fields: [{ key: 'apiBase', label: 'Server URL', type: 'text', required: true, placeholder: 'http://localhost:11434' }],
+        routingLive: false,
+    },
+];
+function getProviderDefinition(id) {
+    return exports.PROVIDER_REGISTRY.find((p) => p.id === id);
+}
+function isKnownProviderId(id) {
+    return exports.PROVIDER_REGISTRY.some((p) => p.id === id);
+}
+/**
+ * Which provider the data-plane proxy would route a model name to.
+ *
+ * A hand-maintained TS mirror of `get_model_provider` in
+ * `packages/proxy/src/proxy.rs` — the proxy's routing decision is the ground
+ * truth, and this exists so the control plane / dashboard can predict it
+ * (e.g. the BYO judge model "Test" flow fast-failing on an unprovisioned
+ * provider before making a real call, LLD #70). A parity unit test pins this
+ * against the Rust source; if the heuristic changes there, change it here in
+ * the same commit.
+ *
+ * Order matters and matches the Rust exactly: claude → gemini → '/'
+ * (OpenRouter's vendor/model namespacing — checked before the mistral
+ * prefixes so "mistralai/..." routes to OpenRouter) → mistral prefixes →
+ * OpenAI as the default arm.
+ */
+function inferProviderForModel(model) {
+    const m = model.toLowerCase();
+    if (m.includes('claude'))
+        return 'anthropic';
+    if (m.includes('gemini'))
+        return 'gemini';
+    if (m.includes('/'))
+        return 'openrouter';
+    if (m.startsWith('mistral') || m.startsWith('open-mixtral') || m.startsWith('codestral')) {
+        return 'mistral';
+    }
+    return 'openai';
+}
+//# sourceMappingURL=providers.js.map

package/dist/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"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"}

package/dist/rulePredicateDsl.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The closed-vocabulary predicate language, and its deterministic renderer.
+ *
+ * A generated rule is described here as JSON and turned into AssemblyScript by
+ * `renderRule`. **The generator never emits AssemblyScript.** That boundary is
+ * the whole design, and it exists because the starter rule library encodes three
+ * inversions an LLM writing source would reintroduce:
+ *
+ *   - `-1` means **unknown**, not zero. A rule written
+ *     `if (spend > budget)` reads unknown as "under budget"; one written
+ *     `if (remaining < 10)` reads it as "broke" and blocks every request
+ *     outside a workflow.
+ *   - An **empty** allowlist means unrestricted, not "permit nothing". Reading
+ *     it the other way blocks every request in a workspace that never declared
+ *     one.
+ *   - `new_tool_calls` is this turn's delta; `tool_sequence` is the whole
+ *     session. Matching a hold against history re-fires it forever.
+ *
+ * Each of those is a one-token difference in source and a *structural*
+ * impossibility in the DSL: there is no operator that compares an optional
+ * numeric without the unknown check, and `listEmpty` is spelled differently from
+ * `notIn`.
+ *
+ * ## Closed by construction
+ *
+ * `FIELDS` below is the vocabulary. A field the guest parser does not read
+ * cannot be named, so a predicate cannot reference something that will silently
+ * be zero at runtime — the shape that produced every inert control in this
+ * codebase. `check-rule-dsl-fields.js` asserts the table against the SDK's real
+ * parser.
+ *
+ * @module
+ */
+/** Types the DSL can reason about, mapped to what the guest exposes. */
+export type FieldKind = 'string' | 'int' | 'float' | 'optionalFloat' | 'optionalInt' | 'stringList' | 'bool';
+/**
+ * Every field a predicate may name, with the guest type it resolves to.
+ *
+ * Derived by hand from `packages/wasm-sdk/assembly/index.ts` and gated against
+ * it. Deliberately excludes the structured lists (`tools`, `tool_calls`,
+ * `changes`, `tool_call_counts`, the four SOP rule arrays) — comparing those
+ * needs operators this vocabulary does not have, and half-supporting them
+ * would let a generator produce a predicate that renders to something that
+ * always evaluates false.
+ */
+export declare const FIELDS: Record<string, FieldKind>;
+/** Operators, each valid only for certain field kinds. */
+export declare const OPERATORS: {
+    readonly equals: readonly ["string"];
+    readonly notEquals: readonly ["string"];
+    readonly isTrue: readonly ["bool"];
+    readonly isFalse: readonly ["bool"];
+    /** Membership in this turn's delta or the session history. */
+    readonly contains: readonly ["stringList"];
+    readonly notContains: readonly ["stringList"];
+    /** The empty-list-means-unrestricted case, spelled so it cannot be confused. */
+    readonly listEmpty: readonly ["stringList"];
+    readonly listNotEmpty: readonly ["stringList"];
+    /**
+     * `atLeast` / `atMost` on an optional numeric render WITH the unknown guard.
+     * There is no operator that compares one without it.
+     */
+    readonly atLeast: readonly ["int", "float", "optionalFloat", "optionalInt"];
+    readonly atMost: readonly ["int", "float", "optionalFloat", "optionalInt"];
+    /** Compares two optional numerics; unknown on either side yields false. */
+    readonly exceedsField: readonly ["optionalFloat"];
+};
+export type Operator = keyof typeof OPERATORS;
+export interface Condition {
+    field: string;
+    op: Operator;
+    /** Absent for `isTrue`/`isFalse`/`listEmpty`/`listNotEmpty`. */
+    value?: string | number;
+}
+export interface Predicate {
+    /** Conditions are ANDed. Deliberately no OR: a rule that fires for two
+     *  unrelated reasons is two rules, and shadow evidence for one of them says
+     *  nothing about the other. */
+    all: Condition[];
+}
+export declare class PredicateError extends Error {
+}
+/** Rejects anything the vocabulary does not permit, with the reason. */
+export declare function validatePredicate(p: unknown): asserts p is Predicate;
+/** Verdict codes the renderer will emit. 2 is deprecated and refused. */
+export declare const RENDERABLE_VERDICTS: readonly [1, 3];
+/**
+ * Renders a validated predicate to standalone AssemblyScript.
+ *
+ * Deterministic: the same predicate always produces byte-identical source, so a
+ * candidate's compiled hash is reproducible and a reviewer diffing two versions
+ * sees only what actually changed.
+ */
+export declare function renderRule(input: {
+    predicate: Predicate;
+    verdict: number;
+    title: string;
+    rationale: string;
+    candidateId: string;
+}): string;
+//# sourceMappingURL=rulePredicateDsl.d.ts.map

package/dist/rulePredicateDsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulePredicateDsl.d.ts","sourceRoot":"","sources":["../src/rulePredicateDsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,eAAe,GAAG,aAAa,GAAG,YAAY,GAAG,MAAM,CAAA;AAE5G;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CA2B5C,CAAA;AAED,0DAA0D;AAC1D,eAAO,MAAM,SAAS;;;;;IAKpB,8DAA8D;;;IAG9D,gFAAgF;;;IAGhF;;;OAGG;;;IAGH,2EAA2E;;CAEnE,CAAA;AAEV,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,SAAS,CAAA;AAE7C,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,EAAE,QAAQ,CAAA;IACZ,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,SAAS;IACxB;;mCAE+B;IAC/B,GAAG,EAAE,SAAS,EAAE,CAAA;CACjB;AAED,qBAAa,cAAe,SAAQ,KAAK;CAAG;AAE5C,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,IAAI,SAAS,CAgEpE;AAiDD,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,iBAAkB,CAAA;AAElD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAChC,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,GAAG,MAAM,CAwDT"}

package/dist/rulePredicateDsl.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * The closed-vocabulary predicate language, and its deterministic renderer.
+ *
+ * A generated rule is described here as JSON and turned into AssemblyScript by
+ * `renderRule`. **The generator never emits AssemblyScript.** That boundary is
+ * the whole design, and it exists because the starter rule library encodes three
+ * inversions an LLM writing source would reintroduce:
+ *
+ *   - `-1` means **unknown**, not zero. A rule written
+ *     `if (spend > budget)` reads unknown as "under budget"; one written
+ *     `if (remaining < 10)` reads it as "broke" and blocks every request
+ *     outside a workflow.
+ *   - An **empty** allowlist means unrestricted, not "permit nothing". Reading
+ *     it the other way blocks every request in a workspace that never declared
+ *     one.
+ *   - `new_tool_calls` is this turn's delta; `tool_sequence` is the whole
+ *     session. Matching a hold against history re-fires it forever.
+ *
+ * Each of those is a one-token difference in source and a *structural*
+ * impossibility in the DSL: there is no operator that compares an optional
+ * numeric without the unknown check, and `listEmpty` is spelled differently from
+ * `notIn`.
+ *
+ * ## Closed by construction
+ *
+ * `FIELDS` below is the vocabulary. A field the guest parser does not read
+ * cannot be named, so a predicate cannot reference something that will silently
+ * be zero at runtime — the shape that produced every inert control in this
+ * codebase. `check-rule-dsl-fields.js` asserts the table against the SDK's real
+ * parser.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDERABLE_VERDICTS = exports.PredicateError = exports.OPERATORS = exports.FIELDS = void 0;
+exports.validatePredicate = validatePredicate;
+exports.renderRule = renderRule;
+/**
+ * Every field a predicate may name, with the guest type it resolves to.
+ *
+ * Derived by hand from `packages/wasm-sdk/assembly/index.ts` and gated against
+ * it. Deliberately excludes the structured lists (`tools`, `tool_calls`,
+ * `changes`, `tool_call_counts`, the four SOP rule arrays) — comparing those
+ * needs operators this vocabulary does not have, and half-supporting them
+ * would let a generator produce a predicate that renders to something that
+ * always evaluates false.
+ */
+exports.FIELDS = {
+    model: 'string',
+    harness: 'string',
+    risk_tier: 'string',
+    agent_role: 'string',
+    estimated_input_tokens: 'int',
+    depth: 'int',
+    graph_node_count: 'int',
+    calls_last_60s: 'int',
+    budget_remaining_usd: 'float',
+    // Optional numerics arrive as -1 when the host has nothing to send. The
+    // `optional` kinds are what force an unknown check into the rendered source.
+    graph_spend_usd: 'optionalFloat',
+    graph_budget_usd: 'optionalFloat',
+    workflow_spend_usd: 'optionalFloat',
+    workflow_budget_usd: 'optionalFloat',
+    parent_alive: 'optionalInt',
+    tool_sequence: 'stringList',
+    new_tool_calls: 'stringList',
+    injection_findings: 'stringList',
+    injection_sources: 'stringList',
+    denied_tools: 'stringList',
+    allowed_harnesses: 'stringList',
+    review_before: 'stringList',
+    plan_steps: 'stringList',
+    scope_paths: 'stringList',
+    tool_contract_changed: 'bool',
+};
+/** Operators, each valid only for certain field kinds. */
+exports.OPERATORS = {
+    equals: ['string'],
+    notEquals: ['string'],
+    isTrue: ['bool'],
+    isFalse: ['bool'],
+    /** Membership in this turn's delta or the session history. */
+    contains: ['stringList'],
+    notContains: ['stringList'],
+    /** The empty-list-means-unrestricted case, spelled so it cannot be confused. */
+    listEmpty: ['stringList'],
+    listNotEmpty: ['stringList'],
+    /**
+     * `atLeast` / `atMost` on an optional numeric render WITH the unknown guard.
+     * There is no operator that compares one without it.
+     */
+    atLeast: ['int', 'float', 'optionalFloat', 'optionalInt'],
+    atMost: ['int', 'float', 'optionalFloat', 'optionalInt'],
+    /** Compares two optional numerics; unknown on either side yields false. */
+    exceedsField: ['optionalFloat'],
+};
+class PredicateError extends Error {
+}
+exports.PredicateError = PredicateError;
+/** Rejects anything the vocabulary does not permit, with the reason. */
+function validatePredicate(p) {
+    if (!p || typeof p !== 'object' || !Array.isArray(p.all)) {
+        throw new PredicateError('predicate must be { all: Condition[] }');
+    }
+    const all = p.all;
+    if (all.length === 0) {
+        throw new PredicateError('predicate has no conditions, so it would fire on every request');
+    }
+    if (all.length > 8) {
+        throw new PredicateError(`predicate has ${all.length} conditions; more than 8 is not a rule anyone can review`);
+    }
+    for (const c of all) {
+        const kind = exports.FIELDS[c.field];
+        if (!kind) {
+            throw new PredicateError(`"${c.field}" is not a field a rule may read. A predicate naming a field ` +
+                'the guest does not parse renders to a comparison against a default, ' +
+                'which is a rule that silently never fires.');
+        }
+        const allowed = exports.OPERATORS[c.op];
+        if (!allowed)
+            throw new PredicateError(`"${c.op}" is not an operator`);
+        if (!allowed.includes(kind)) {
+            throw new PredicateError(`"${c.op}" cannot apply to ${c.field}, which is ${kind}`);
+        }
+        const needsValue = !['isTrue', 'isFalse', 'listEmpty', 'listNotEmpty'].includes(c.op);
+        if (needsValue && (c.value === undefined || c.value === null)) {
+            throw new PredicateError(`"${c.op}" on ${c.field} needs a value`);
+        }
+        if (!needsValue && c.value !== undefined) {
+            throw new PredicateError(`"${c.op}" on ${c.field} takes no value`);
+        }
+        if (needsValue) {
+            // `exceedsField` compares two fields, so its value is a field NAME even
+            // though the field it applies to is numeric. Checked before the type rule
+            // below, which would otherwise reject every valid use of it.
+            if (c.op === 'exceedsField') {
+                if (typeof c.value !== 'string' || !exports.FIELDS[c.value]) {
+                    throw new PredicateError(`exceedsField must name a field; "${String(c.value)}" is not one`);
+                }
+                if (!String(exports.FIELDS[c.value]).startsWith('optional')) {
+                    throw new PredicateError(`exceedsField compares two optional numerics; ${String(c.value)} is ${exports.FIELDS[c.value]}`);
+                }
+                continue;
+            }
+            const numeric = ['int', 'float', 'optionalFloat', 'optionalInt'].includes(kind);
+            if (numeric && typeof c.value !== 'number') {
+                throw new PredicateError(`${c.field} is numeric; "${String(c.value)}" is not`);
+            }
+            if (!numeric && typeof c.value !== 'string') {
+                throw new PredicateError(`${c.field} is textual; ${String(c.value)} is not`);
+            }
+        }
+    }
+}
+/** AssemblyScript string literal. Never interpolate a value without this. */
+function lit(v) {
+    return JSON.stringify(v);
+}
+/**
+ * One condition as an AssemblyScript expression.
+ *
+ * The optional-numeric arms carry their own `!= -1` guard, which is why the DSL
+ * has no bare comparison operator for them: the guard cannot be forgotten
+ * because there is no way to express the comparison without it.
+ */
+function renderCondition(c) {
+    const f = `ctx.${c.field}`;
+    switch (c.op) {
+        case 'equals':
+            return `${f} == ${lit(String(c.value))}`;
+        case 'notEquals':
+            return `${f} != ${lit(String(c.value))}`;
+        case 'isTrue':
+            return f;
+        case 'isFalse':
+            return `!${f}`;
+        case 'contains':
+            return `listHas(${f}, ${lit(String(c.value))})`;
+        case 'notContains':
+            return `!listHas(${f}, ${lit(String(c.value))})`;
+        case 'listEmpty':
+            return `${f}.length == 0`;
+        case 'listNotEmpty':
+            return `${f}.length > 0`;
+        case 'atLeast':
+            return exports.FIELDS[c.field].startsWith('optional')
+                ? `(${f} != -1 && ${f} >= ${c.value})`
+                : `${f} >= ${c.value}`;
+        case 'atMost':
+            return exports.FIELDS[c.field].startsWith('optional')
+                ? `(${f} != -1 && ${f} <= ${c.value})`
+                : `${f} <= ${c.value}`;
+        case 'exceedsField': {
+            const other = `ctx.${String(c.value)}`;
+            // Both sides must be known. Unknown on either yields false, never a block.
+            return `(${f} != -1 && ${other} != -1 && ${other} != 0 && ${f} >= ${other})`;
+        }
+    }
+}
+/** Verdict codes the renderer will emit. 2 is deprecated and refused. */
+exports.RENDERABLE_VERDICTS = [1, 3];
+/**
+ * Renders a validated predicate to standalone AssemblyScript.
+ *
+ * Deterministic: the same predicate always produces byte-identical source, so a
+ * candidate's compiled hash is reproducible and a reviewer diffing two versions
+ * sees only what actually changed.
+ */
+function renderRule(input) {
+    validatePredicate(input.predicate);
+    if (!exports.RENDERABLE_VERDICTS.includes(input.verdict)) {
+        throw new PredicateError(`verdict ${input.verdict} is not renderable. 1 blocks, 3 reasks; 0 would be a ` +
+            'rule that does nothing and 2 is deprecated — the proxy maps it to a block.');
+    }
+    const conditions = input.predicate.all.map(renderCondition);
+    // One condition per line, ANDed. Formatted rather than joined into one
+    // expression so a reviewer can read the generated source at all.
+    const expr = conditions.map((c) => `    ${c}`).join(' &&\n');
+    // Comments carry no backticks or ${: this string is assembled here, but the
+    // title and rationale come from a generator and must not be able to terminate
+    // anything downstream. JSON-encoding them makes that structural.
+    //
+    // That goes for the candidate id too, which was the one field interpolated
+    // raw while the comment above claimed all three were encoded. A `//` comment
+    // is terminated by a newline, so an id carrying one moved whatever followed it
+    // onto a line of its own — as AssemblyScript, in a file about to be compiled
+    // and loaded as a policy rule. Only tests construct ids today, which is what
+    // made it latent rather than live.
+    return `// Generated by Intutic from reviewed decisions. Do not edit.
+//
+// Candidate: ${JSON.stringify(input.candidateId)}
+// Title:     ${JSON.stringify(input.title)}
+// Rationale: ${JSON.stringify(input.rationale)}
+//
+// Rendered deterministically from a closed-vocabulary predicate; the generator
+// does not write AssemblyScript. Verdict ${input.verdict} — 1 blocks, 3 reasks.
+import { RequestContext, readContext } from "../../assembly/index";
+
+export { allocate } from "../../assembly/index";
+
+function listHas(xs: string[], needle: string): bool {
+  for (let i = 0; i < xs.length; i++) {
+    if (xs[i] == needle) return true;
+  }
+  return false;
+}
+
+export function rule(ctx: RequestContext): i32 {
+  if (
+${expr}
+  ) {
+    return ${input.verdict};
+  }
+  return 0;
+}
+
+export function evaluate(offset: i32, len: i32): i32 {
+  return rule(readContext(offset, len));
+}
+`;
+}
+//# sourceMappingURL=rulePredicateDsl.js.map

package/dist/rulePredicateDsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulePredicateDsl.js","sourceRoot":"","sources":["../src/rulePredicateDsl.ts"],"names":[],"mappings":"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"}

package/dist/rulePredicateEval.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The TypeScript reading of a predicate — the same arithmetic `renderRule`
+ * emits, evaluated over a stored context snapshot instead of compiled.
+ *
+ * Used where a compiled bundle does not exist yet: picking a block mock and
+ * a near-miss for a policy-cited candidate (`/mocks` in citation mode) and
+ * previewing "N of M captured contexts would have fired" for a `wasm_rule`
+ * guardrail before anyone compiles anything. It decides nothing about
+ * enforcement: the compiled rule is what the proxy runs, and the bundle
+ * gates (`discriminates`, `historical_replay`) still run the real binary.
+ *
+ * Parity with the binary is pinned in
+ * `packages/wasm-sdk/__tests__/generatedRules.test.ts`, which asserts this
+ * function and the compiled module agree on every semantic case. That test
+ * is the reason this file mirrors the guest's *defaults* as well as its
+ * operators: a field the snapshot does not carry reads as `""`, `0`, `-1`
+ * (optional numerics), `[]` or `false`, exactly as `readContext` leaves it.
+ *
+ * @module
+ */
+import { type Predicate } from './rulePredicateDsl.js';
+/**
+ * Does this predicate fire on this snapshot? `true` means the compiled rule
+ * would return its verdict; `false` means it would return 0 (allow).
+ *
+ * Does not validate: call {@link compilePredicate} to validate once and
+ * evaluate many times, or `validatePredicate` yourself first.
+ */
+export declare function evaluatePredicate(predicate: Predicate, ctx: Record<string, unknown>): boolean;
+/**
+ * Validate once, evaluate many. Throws `PredicateError` on anything outside
+ * the vocabulary — the same refusal `renderRule` gives — so a stored
+ * predicate that could not compile never reads as "fires on nothing".
+ */
+export declare function compilePredicate(predicate: unknown): (ctx: Record<string, unknown>) => boolean;
+/** Every string literal a predicate compares against; what a citation must ground. */
+export declare function predicateStringValues(predicate: Predicate): string[];
+//# sourceMappingURL=rulePredicateEval.d.ts.map

package/dist/rulePredicateEval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulePredicateEval.d.ts","sourceRoot":"","sources":["../src/rulePredicateEval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAA6C,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAuEjG;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAG9F;AAED,sFAAsF;AACtF,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,EAAE,CAOpE"}