@openprose/reactor 0.1.0-rc.1

package/dist/projection/index.d.ts

@@ -0,0 +1,119 @@
+import { type ContentHashV0, type ReceiptProofInspectionV0, type ReceiptVerdictStatusV0 } from "../receipt";
+export declare const RECEIPT_PROJECTION_SCHEMA: "openprose.receipt.projection";
+export declare const RECEIPT_PROJECTION_VERSION: 0;
+export declare const RECEIPT_PROJECTION_TIERS_V0: readonly ["owner", "subscriber", "public"];
+export type ReceiptProjectionSchemaV0 = typeof RECEIPT_PROJECTION_SCHEMA;
+export type ReceiptProjectionVersionV0 = typeof RECEIPT_PROJECTION_VERSION;
+export type ReceiptProjectionTierV0 = (typeof RECEIPT_PROJECTION_TIERS_V0)[number];
+export interface ProjectReceiptInputV0 {
+    readonly tier: string;
+    readonly receipt: unknown;
+}
+export interface ProjectReceiptProofInputV0 {
+    readonly tier: string;
+    readonly proof: unknown;
+    readonly status?: ReceiptVerdictStatusV0 | null;
+}
+export type ReceiptProjectionSignerV0 = {
+    readonly kind: "null";
+    readonly scheme: "none";
+} | {
+    readonly kind: "signed";
+    readonly scheme: string;
+};
+export interface ReceiptProjectionFreshnessV0 {
+    readonly as_of: string;
+    readonly next_forecast_recheck: string;
+    readonly transitive_freshness_policy_ref: string | null;
+    readonly consumed_freshness_evaluated_count: number;
+}
+export interface ReceiptPublicCompositionPinProjectionV0 {
+    readonly upstream_content_hash: ContentHashV0;
+    readonly contract_revision: ContentHashV0;
+    readonly acceptable_signer_set_count: number;
+}
+export interface ReceiptSubscriberCompositionPinProjectionV0 {
+    readonly upstream_content_hash: ContentHashV0;
+    readonly contract_revision: ContentHashV0;
+    readonly acceptable_signer_set: readonly string[];
+}
+export interface ReceiptPublicCompositionProjectionV0 {
+    readonly consumed_receipt_count: number;
+    readonly consumed_receipts: readonly ReceiptPublicCompositionPinProjectionV0[];
+    readonly cycle_checked: boolean;
+}
+export interface ReceiptSubscriberCompositionProjectionV0 {
+    readonly consumed_receipt_count: number;
+    readonly consumed_receipts: readonly ReceiptSubscriberCompositionPinProjectionV0[];
+    readonly cycle_checked: boolean;
+}
+export interface ReceiptPublicTokenTruthProjectionV0 {
+    readonly fresh: number;
+    readonly reused: number;
+    readonly role: string;
+    readonly surprise_cause: string;
+}
+export interface ReceiptSubscriberTokenTruthProjectionV0 extends ReceiptPublicTokenTruthProjectionV0 {
+    readonly provider: string;
+    readonly model: string;
+}
+export interface ReceiptOwnerVerdictProjectionV0 {
+    readonly status: ReceiptVerdictStatusV0 | null;
+    readonly confidence: {
+        readonly value: number | null;
+        readonly derivation_method: string | null;
+        readonly calibration_grade: string | null;
+        readonly label_source: string | null;
+    } | null;
+    readonly blocked: {
+        readonly reason: string | null;
+        readonly fix_target: string | null;
+        readonly interrupt_cause: string | null;
+    } | null;
+}
+export interface ReceiptProjectionBaseV0 {
+    readonly schema: ReceiptProjectionSchemaV0;
+    readonly v: ReceiptProjectionVersionV0;
+    readonly tier: ReceiptProjectionTierV0;
+    readonly receipt_id: ContentHashV0;
+    readonly content_hash: ContentHashV0;
+    readonly contract_revision: ContentHashV0;
+    readonly status: ReceiptVerdictStatusV0 | null;
+    readonly signer: ReceiptProjectionSignerV0;
+    readonly freshness: ReceiptProjectionFreshnessV0;
+}
+export interface ReceiptOwnerProjectionV0 extends ReceiptProjectionBaseV0 {
+    readonly tier: "owner";
+    readonly responsibility_id: string;
+    readonly role: string;
+    readonly composition: ReceiptSubscriberCompositionProjectionV0;
+    readonly token_truth: ReceiptSubscriberTokenTruthProjectionV0;
+    readonly verdict: ReceiptOwnerVerdictProjectionV0;
+    readonly proof: ReceiptProofInspectionV0;
+}
+export interface ReceiptSubscriberProjectionV0 extends ReceiptProjectionBaseV0 {
+    readonly tier: "subscriber";
+    readonly responsibility_id: string;
+    readonly role: string;
+    readonly composition: ReceiptSubscriberCompositionProjectionV0;
+    readonly token_truth: ReceiptSubscriberTokenTruthProjectionV0;
+}
+export interface ReceiptPublicProjectionV0 extends ReceiptProjectionBaseV0 {
+    readonly tier: "public";
+    readonly composition: ReceiptPublicCompositionProjectionV0;
+    readonly token_truth: ReceiptPublicTokenTruthProjectionV0;
+}
+export type ReceiptProjectionV0 = ReceiptOwnerProjectionV0 | ReceiptSubscriberProjectionV0 | ReceiptPublicProjectionV0;
+export type ReceiptProjectionResultV0 = {
+    readonly ok: true;
+    readonly tier: ReceiptProjectionTierV0;
+    readonly projection: ReceiptProjectionV0;
+} | {
+    readonly ok: false;
+    readonly tier: ReceiptProjectionTierV0 | null;
+    readonly errors: readonly string[];
+    readonly projection: null;
+};
+export declare function projectReceiptV0(input: ProjectReceiptInputV0): ReceiptProjectionResultV0;
+export declare function projectReceiptProofV0(input: ProjectReceiptProofInputV0): ReceiptProjectionResultV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/projection/index.d.ts.map

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

package/dist/projection/index.js

@@ -0,0 +1,506 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECEIPT_PROJECTION_TIERS_V0 = exports.RECEIPT_PROJECTION_VERSION = exports.RECEIPT_PROJECTION_SCHEMA = void 0;
+exports.projectReceiptV0 = projectReceiptV0;
+exports.projectReceiptProofV0 = projectReceiptProofV0;
+const receipt_1 = require("../receipt");
+exports.RECEIPT_PROJECTION_SCHEMA = "openprose.receipt.projection";
+exports.RECEIPT_PROJECTION_VERSION = 0;
+exports.RECEIPT_PROJECTION_TIERS_V0 = [
+    "owner",
+    "subscriber",
+    "public",
+];
+const CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const PROJECTION_TIERS = new Set(exports.RECEIPT_PROJECTION_TIERS_V0);
+const RECEIPT_STATUSES = new Set([
+    "up",
+    "drifting",
+    "down",
+    "blocked",
+]);
+const OPENROUTER_SECRET_PREFIX = ["sk", "or"].join("-");
+const PRIVATE_OUTPUT_KEYS = new Set([
+    "customer_payload",
+    "evidence_payload",
+    "judge_rationale",
+    "memo_key",
+    "provider_norm",
+    "rationale",
+    "raw_evidence",
+    "raw_evidence_payload",
+    "run_id",
+    "tags",
+]);
+const SECRET_SHAPED_PATTERNS = [
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
+    /\bBearer\s+[A-Za-z0-9._-]{8,}\b/i,
+    new RegExp(`\\b${escapeRegex(OPENROUTER_SECRET_PREFIX)}-[A-Za-z0-9._-]{8,}\\b`),
+    /\bapi[_-]?key[_:/= -]+[A-Za-z0-9._-]{8,}\b/i,
+    /\b(?:secret|token|password|credential|authorization)[_:/= -]+[A-Za-z0-9._-]{8,}\b/i,
+    /\bhttps?:\/\/(?:localhost|127(?:\.\d{1,3}){3}|10(?:\.\d{1,3}){3}|192\.168(?:\.\d{1,3}){2}|172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2}|[^/\s?#]+(?:\.internal|\.local))(?::\d+)?(?:[/?#][^\s]*)?/i,
+    /\bhttps?:\/\/[^\s?#]+[/?#][^\s]*(?:token|secret|signature|credential|password)=/i,
+];
+function projectReceiptV0(input) {
+    const tier = normalizeTier(input.tier);
+    if (tier === null) {
+        return failProjection(null, ["unknown projection tier"]);
+    }
+    const proof = (0, receipt_1.inspectReceiptProofV0)(input.receipt);
+    if (!proof.ok) {
+        return failProjection(tier, ["receipt failed verification"]);
+    }
+    const normalized = normalizeProof(proof);
+    if (!normalized.ok) {
+        return failProjection(tier, normalized.errors);
+    }
+    const status = readReceiptStatus(input.receipt);
+    if (status === null) {
+        return failProjection(tier, ["receipt status is malformed"]);
+    }
+    return projectNormalizedProof({
+        tier,
+        proof: normalized.proof,
+        status,
+        verdict: readOwnerVerdict(input.receipt, status),
+    });
+}
+function projectReceiptProofV0(input) {
+    const tier = normalizeTier(input.tier);
+    if (tier === null) {
+        return failProjection(null, ["unknown projection tier"]);
+    }
+    const normalized = normalizeProof(input.proof);
+    if (!normalized.ok) {
+        return failProjection(tier, normalized.errors);
+    }
+    const status = input.status === undefined || input.status === null
+        ? null
+        : normalizeStatus(input.status);
+    if (input.status !== undefined && input.status !== null && status === null) {
+        return failProjection(tier, ["receipt status is malformed"]);
+    }
+    return projectNormalizedProof({
+        tier,
+        proof: normalized.proof,
+        status,
+        verdict: {
+            status,
+            confidence: null,
+            blocked: null,
+        },
+    });
+}
+function projectNormalizedProof(input) {
+    const base = {
+        schema: exports.RECEIPT_PROJECTION_SCHEMA,
+        v: exports.RECEIPT_PROJECTION_VERSION,
+        tier: input.tier,
+        receipt_id: input.proof.content_hash,
+        content_hash: input.proof.content_hash,
+        contract_revision: input.proof.contract_revision,
+        status: input.status,
+        signer: input.proof.signer,
+        freshness: input.proof.freshness,
+    };
+    const projection = buildProjection(input.tier, base, input.proof, input.verdict);
+    if ((input.tier === "public" || input.tier === "subscriber") &&
+        hasPublicProjectionLeak(projection)) {
+        return failProjection(input.tier, ["projection would expose secret-shaped data"]);
+    }
+    return {
+        ok: true,
+        tier: input.tier,
+        projection,
+    };
+}
+function buildProjection(tier, base, proof, verdict) {
+    switch (tier) {
+        case "owner":
+            return {
+                ...base,
+                tier,
+                responsibility_id: proof.responsibility_id,
+                role: proof.role,
+                composition: proof.composition,
+                token_truth: proof.token_truth,
+                verdict,
+                proof: proof.inspection,
+            };
+        case "subscriber":
+            return {
+                ...base,
+                tier,
+                responsibility_id: proof.responsibility_id,
+                role: proof.role,
+                composition: proof.composition,
+                token_truth: proof.token_truth,
+            };
+        case "public":
+            return {
+                ...base,
+                tier,
+                composition: {
+                    consumed_receipt_count: proof.composition.consumed_receipt_count,
+                    consumed_receipts: proof.composition.consumed_receipts.map((pin) => ({
+                        upstream_content_hash: pin.upstream_content_hash,
+                        contract_revision: pin.contract_revision,
+                        acceptable_signer_set_count: pin.acceptable_signer_set.length,
+                    })),
+                    cycle_checked: proof.composition.cycle_checked,
+                },
+                token_truth: {
+                    fresh: proof.token_truth.fresh,
+                    reused: proof.token_truth.reused,
+                    role: proof.token_truth.role,
+                    surprise_cause: proof.token_truth.surprise_cause,
+                },
+            };
+    }
+}
+function normalizeTier(tier) {
+    return PROJECTION_TIERS.has(tier) ? tier : null;
+}
+function normalizeProof(value) {
+    const errors = [];
+    const proof = expectRecord(value, "receipt proof", errors);
+    if (proof === undefined) {
+        return { ok: false, errors };
+    }
+    if (proof["ok"] !== true) {
+        errors.push("receipt proof must be verified");
+    }
+    const proofErrors = proof["errors"];
+    if (!Array.isArray(proofErrors) ||
+        proofErrors.length > 0 ||
+        proofErrors.some((item) => typeof item !== "string")) {
+        errors.push("receipt proof errors must be empty");
+    }
+    if (proof["schema"] !== receipt_1.RECEIPT_SCHEMA) {
+        errors.push("receipt proof schema is malformed");
+    }
+    if (proof["v"] !== receipt_1.RECEIPT_VERSION) {
+        errors.push("receipt proof version is malformed");
+    }
+    const contentHash = readContentHash(proof, "content_hash", errors);
+    const contractRevision = readContentHash(proof, "contract_revision", errors);
+    const responsibilityId = readNonEmptyString(proof, "responsibility_id", errors);
+    const role = readNonEmptyString(proof, "role", errors);
+    const signer = normalizeSigner(proof["signer"], errors);
+    const freshness = normalizeFreshness(proof["freshness"], errors);
+    const composition = normalizeComposition(proof["composition"], errors);
+    const tokenTruth = normalizeTokenTruth(proof["token_truth"], errors);
+    if (errors.length > 0 ||
+        contentHash === null ||
+        contractRevision === null ||
+        responsibilityId === null ||
+        role === null ||
+        signer === null ||
+        freshness === null ||
+        composition === null ||
+        tokenTruth === null) {
+        return { ok: false, errors };
+    }
+    const inspection = {
+        ok: true,
+        errors: [],
+        schema: receipt_1.RECEIPT_SCHEMA,
+        v: receipt_1.RECEIPT_VERSION,
+        content_hash: contentHash,
+        contract_revision: contractRevision,
+        responsibility_id: responsibilityId,
+        role,
+        signer,
+        freshness: {
+            as_of: freshness.as_of,
+            next_forecast_recheck: freshness.next_forecast_recheck,
+            transitive_freshness_policy_ref: freshness.transitive_freshness_policy_ref,
+            consumed_freshness_evaluated_count: freshness.consumed_freshness_evaluated_count,
+        },
+        composition: {
+            consumed_receipt_count: composition.consumed_receipt_count,
+            consumed_receipts: composition.consumed_receipts,
+            cycle_checked: composition.cycle_checked,
+        },
+        token_truth: {
+            fresh: tokenTruth.fresh,
+            reused: tokenTruth.reused,
+            provider: tokenTruth.provider,
+            model: tokenTruth.model,
+            role: tokenTruth.role,
+            surprise_cause: tokenTruth.surprise_cause,
+        },
+    };
+    return {
+        ok: true,
+        proof: {
+            inspection,
+            content_hash: contentHash,
+            contract_revision: contractRevision,
+            responsibility_id: responsibilityId,
+            role,
+            signer,
+            freshness,
+            composition,
+            token_truth: tokenTruth,
+        },
+    };
+}
+function normalizeSigner(value, errors) {
+    const signer = expectRecord(value, "receipt proof signer", errors);
+    if (signer === undefined) {
+        return null;
+    }
+    const kind = readString(signer, "kind");
+    const scheme = readNonEmptyString(signer, "scheme", errors);
+    if (scheme === null) {
+        return null;
+    }
+    if (kind === "null" && scheme === "none") {
+        return { kind, scheme };
+    }
+    if (kind === "signed" && scheme !== "none") {
+        return { kind, scheme };
+    }
+    errors.push("receipt proof signer is malformed");
+    return null;
+}
+function normalizeFreshness(value, errors) {
+    const freshness = expectRecord(value, "receipt proof freshness", errors);
+    if (freshness === undefined) {
+        return null;
+    }
+    const asOf = readIsoInstant(freshness, "as_of", errors);
+    const nextForecastRecheck = readIsoInstant(freshness, "next_forecast_recheck", errors);
+    const transitiveRef = readNullableString(freshness, "transitive_freshness_policy_ref", errors);
+    const consumedCount = readNonNegativeInteger(freshness, "consumed_freshness_evaluated_count", errors);
+    if (asOf === null || nextForecastRecheck === null || consumedCount === null) {
+        return null;
+    }
+    return {
+        as_of: asOf,
+        next_forecast_recheck: nextForecastRecheck,
+        transitive_freshness_policy_ref: transitiveRef,
+        consumed_freshness_evaluated_count: consumedCount,
+    };
+}
+function normalizeComposition(value, errors) {
+    const composition = expectRecord(value, "receipt proof composition", errors);
+    if (composition === undefined) {
+        return null;
+    }
+    const consumedCount = readNonNegativeInteger(composition, "consumed_receipt_count", errors);
+    const cycleChecked = readBoolean(composition, "cycle_checked", errors);
+    const consumedReceiptsValue = composition["consumed_receipts"];
+    if (!Array.isArray(consumedReceiptsValue)) {
+        errors.push("receipt proof composition consumed receipts are malformed");
+        return null;
+    }
+    const consumedReceipts = [];
+    for (const item of consumedReceiptsValue) {
+        const pin = expectRecord(item, "receipt proof composition pin", errors);
+        if (pin === undefined) {
+            continue;
+        }
+        const upstreamContentHash = readContentHash(pin, "upstream_content_hash", errors);
+        const contractRevision = readContentHash(pin, "contract_revision", errors);
+        const acceptableSignerSet = readStringArray(pin, "acceptable_signer_set", errors);
+        if (upstreamContentHash !== null &&
+            contractRevision !== null &&
+            acceptableSignerSet !== null) {
+            consumedReceipts.push({
+                upstream_content_hash: upstreamContentHash,
+                contract_revision: contractRevision,
+                acceptable_signer_set: acceptableSignerSet,
+            });
+        }
+    }
+    if (consumedCount === null || cycleChecked === null) {
+        return null;
+    }
+    if (consumedReceipts.length !== consumedCount) {
+        errors.push("receipt proof composition count is malformed");
+        return null;
+    }
+    return {
+        consumed_receipt_count: consumedCount,
+        consumed_receipts: consumedReceipts,
+        cycle_checked: cycleChecked,
+    };
+}
+function normalizeTokenTruth(value, errors) {
+    const tokenTruth = expectRecord(value, "receipt proof token truth", errors);
+    if (tokenTruth === undefined) {
+        return null;
+    }
+    const fresh = readNonNegativeInteger(tokenTruth, "fresh", errors);
+    const reused = readNonNegativeInteger(tokenTruth, "reused", errors);
+    const provider = readNonEmptyString(tokenTruth, "provider", errors);
+    const model = readNonEmptyString(tokenTruth, "model", errors);
+    const role = readNonEmptyString(tokenTruth, "role", errors);
+    const surpriseCause = readNonEmptyString(tokenTruth, "surprise_cause", errors);
+    if (fresh === null ||
+        reused === null ||
+        provider === null ||
+        model === null ||
+        role === null ||
+        surpriseCause === null) {
+        return null;
+    }
+    return {
+        fresh,
+        reused,
+        provider,
+        model,
+        role,
+        surprise_cause: surpriseCause,
+    };
+}
+function readReceiptStatus(value) {
+    const receipt = isRecord(value) ? value : undefined;
+    const verdict = readRecord(receipt, "verdict");
+    return normalizeStatus(readString(verdict, "status"));
+}
+function normalizeStatus(value) {
+    return typeof value === "string" && RECEIPT_STATUSES.has(value)
+        ? value
+        : null;
+}
+function readOwnerVerdict(value, status) {
+    const receipt = isRecord(value) ? value : undefined;
+    const verdict = readRecord(receipt, "verdict");
+    const confidence = readRecord(verdict, "confidence");
+    const blocked = readRecord(verdict, "blocked");
+    return {
+        status,
+        confidence: confidence === undefined
+            ? null
+            : {
+                value: readNumber(confidence, "value"),
+                derivation_method: readString(confidence, "derivation_method"),
+                calibration_grade: readString(confidence, "calibration_grade"),
+                label_source: readString(confidence, "label_source"),
+            },
+        blocked: blocked === undefined
+            ? null
+            : {
+                reason: readString(blocked, "reason"),
+                fix_target: readString(blocked, "fix_target"),
+                interrupt_cause: readString(blocked, "interrupt_cause"),
+            },
+    };
+}
+function hasPublicProjectionLeak(value) {
+    if (Array.isArray(value)) {
+        return value.some(hasPublicProjectionLeak);
+    }
+    if (isRecord(value)) {
+        return Object.entries(value).some(([key, item]) => isForbiddenOutputKey(key) || hasPublicProjectionLeak(item));
+    }
+    return typeof value === "string" && hasSecretShapedText(value);
+}
+function isForbiddenOutputKey(key) {
+    return PRIVATE_OUTPUT_KEYS.has(key.toLowerCase());
+}
+function hasSecretShapedText(value) {
+    return SECRET_SHAPED_PATTERNS.some((pattern) => pattern.test(value));
+}
+function failProjection(tier, errors) {
+    return {
+        ok: false,
+        tier,
+        errors,
+        projection: null,
+    };
+}
+function expectRecord(value, label, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} is malformed`);
+        return undefined;
+    }
+    return value;
+}
+function readRecord(record, key) {
+    const value = record?.[key];
+    return isRecord(value) ? value : undefined;
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value : null;
+}
+function readNonEmptyString(record, key, errors) {
+    const value = readString(record, key);
+    if (value === null || value.length === 0) {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function readNullableString(record, key, errors) {
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    errors.push(`${key} is malformed`);
+    return null;
+}
+function readNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readNonNegativeInteger(record, key, errors) {
+    const value = readNumber(record, key);
+    if (value === null || !Number.isInteger(value) || value < 0) {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function readBoolean(record, key, errors) {
+    const value = record[key];
+    if (typeof value !== "boolean") {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function readIsoInstant(record, key, errors) {
+    const value = readNonEmptyString(record, key, errors);
+    if (value === null) {
+        return null;
+    }
+    if (!ISO_INSTANT_PATTERN.test(value)) {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function readContentHash(record, key, errors) {
+    const value = readNonEmptyString(record, key, errors);
+    if (value === null) {
+        return null;
+    }
+    if (!CONTENT_HASH_PATTERN.test(value)) {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function readStringArray(record, key, errors) {
+    const value = record[key];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        errors.push(`${key} is malformed`);
+        return null;
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/reactor/index.d.ts

@@ -0,0 +1,54 @@
+import { type ForecastScheduleStateV0 } from "../forecast";
+import { type CompiledEvidencePlan } from "../evidence-plan";
+import { type PolicyLiveObservableV0 } from "../policy";
+import { type ContentHashV0, type ReceiptRecheckKindV0, type ReceiptV0 } from "../receipt";
+import type { ReactorCreateInputV0, ReactorIngestResultV0, ReactorRegistrySnapshotV0, ReactorTickResultV0 } from "../sdk";
+export interface ReactorRuntimeV0 {
+    readonly ingest: (event: unknown) => ReactorIngestResultV0;
+    readonly tick: (as_of?: string) => ReactorTickResultV0;
+    readonly receipts: () => readonly ReceiptV0[];
+    readonly registry: () => ReactorRegistrySnapshotV0;
+}
+interface ReactorTurnBaseV0 {
+    readonly contract_revision?: ContentHashV0;
+    readonly cold_start?: ColdStartPolicyInputV0;
+    readonly evidence?: readonly ReactorEvidenceInputV0[];
+    readonly dependency_receipts?: readonly ReceiptV0[];
+}
+export interface ContractSummaryProjectionV0 {
+    readonly summary: string;
+    readonly source_contract_revision: ContentHashV0;
+    readonly projection_hash: ContentHashV0;
+}
+export interface ColdStartPolicyInputV0 {
+    readonly contract_revision: ContentHashV0;
+    readonly contract_summary: ContractSummaryProjectionV0;
+    readonly no_anchor: boolean;
+    readonly live_observables: readonly PolicyLiveObservableV0[];
+    readonly compiled_evidence_plan: CompiledEvidencePlan;
+    readonly forecast_schedule: ForecastScheduleStateV0;
+    readonly policy_artifact_namespace?: string;
+}
+export interface ReactorEvidenceInputV0 {
+    readonly source_id: string;
+    readonly receipt?: ReceiptV0;
+    readonly content_hash?: ContentHashV0;
+    readonly payload?: unknown;
+}
+export interface ReactorRealInputTurnV0 extends ReactorTurnBaseV0 {
+    readonly kind: "real-input";
+}
+export interface ReactorForecastRecheckTurnV0 extends ReactorTurnBaseV0 {
+    readonly kind: "forecast-recheck";
+    readonly recheck_kind: ReceiptRecheckKindV0;
+}
+export interface ReactorEscalationTurnV0 extends ReactorTurnBaseV0 {
+    readonly kind: "escalation";
+    readonly interrupt_cause: "needs-judgment" | "needs-input" | "contract-declared";
+    readonly reason: string;
+    readonly fix_target: string;
+}
+export type ReactorTurnInputV0 = ReactorRealInputTurnV0 | ReactorForecastRecheckTurnV0 | ReactorEscalationTurnV0;
+export declare function createRuntimeReactorV0(input: ReactorCreateInputV0): ReactorRuntimeV0;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/reactor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactor/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,oBAAoB,EAG1B,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EAQL,KAAK,sBAAsB,EAG5B,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,KAAK,aAAa,EAGlB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAMf,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAEV,oBAAoB,EAEpB,qBAAqB,EAIrB,yBAAyB,EAEzB,mBAAmB,EACpB,MAAM,QAAQ,CAAC;AAEhB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,qBAAqB,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,mBAAmB,CAAC;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,SAAS,EAAE,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,yBAAyB,CAAC;CACpD;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,aAAa,CAAC;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,sBAAsB,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACtD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACrD;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,wBAAwB,EAAE,aAAa,CAAC;IACjD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC;CACzC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,2BAA2B,CAAC;IACvD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,EAAE,oBAAoB,CAAC;IACtD,QAAQ,CAAC,iBAAiB,EAAE,uBAAuB,CAAC;IACpD,QAAQ,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;CAC7B;AAED,MAAM,WAAW,4BAA6B,SAAQ,iBAAiB;IACrE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;CAC7C;AAED,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,gBAAgB,GAAG,aAAa,GAAG,mBAAmB,CAAC;IACjF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,kBAAkB,GAC1B,sBAAsB,GACtB,4BAA4B,GAC5B,uBAAuB,CAAC;AA2E5B,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,oBAAoB,GAC1B,gBAAgB,CA0BlB"}