@holoscript/core 8.0.8 → 8.0.9

package/dist/policy/index.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+var chunk7VBKRGIZ_cjs = require('../chunk-7VBKRGIZ.cjs');
+var chunk356N4NPM_cjs = require('../chunk-356N4NPM.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "DEFAULT_BLOCKLIST", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.DEFAULT_BLOCKLIST; }
+});
+Object.defineProperty(exports, "HARD_STOP_CATEGORIES", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.HARD_STOP_CATEGORIES; }
+});
+Object.defineProperty(exports, "POLICY_PACK_COMPILE_TARGETS", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.POLICY_PACK_COMPILE_TARGETS; }
+});
+Object.defineProperty(exports, "POLICY_PACK_FRAMEWORK_IDS", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.POLICY_PACK_FRAMEWORK_IDS; }
+});
+Object.defineProperty(exports, "PolicyPackDefinitionError", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.PolicyPackDefinitionError; }
+});
+Object.defineProperty(exports, "PolicyPackDeploymentError", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.PolicyPackDeploymentError; }
+});
+Object.defineProperty(exports, "assertPolicyPackDeploymentReady", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.assertPolicyPackDeploymentReady; }
+});
+Object.defineProperty(exports, "buildContentPolicyConfig", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.buildContentPolicyConfig; }
+});
+Object.defineProperty(exports, "defaultPolicyPackCompileTargets", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.defaultPolicyPackCompileTargets; }
+});
+Object.defineProperty(exports, "defaultRulesForTier", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.defaultRulesForTier; }
+});
+Object.defineProperty(exports, "definePolicyPack", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.definePolicyPack; }
+});
+Object.defineProperty(exports, "evaluateContentPolicy", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.evaluateContentPolicy; }
+});
+Object.defineProperty(exports, "evaluateContentPolicySync", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.evaluateContentPolicySync; }
+});
+Object.defineProperty(exports, "evaluatePolicyPackDeployment", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.evaluatePolicyPackDeployment; }
+});
+Object.defineProperty(exports, "isPolicyPackCompileTarget", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.isPolicyPackCompileTarget; }
+});
+Object.defineProperty(exports, "isPolicyPackFrameworkId", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.isPolicyPackFrameworkId; }
+});
+Object.defineProperty(exports, "jurisdictionBundle", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.jurisdictionBundle; }
+});
+Object.defineProperty(exports, "matchBlocklist", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.matchBlocklist; }
+});
+Object.defineProperty(exports, "normalizeText", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.normalizeText; }
+});
+Object.defineProperty(exports, "policyPackFromSchemaBlock", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.policyPackFromSchemaBlock; }
+});
+Object.defineProperty(exports, "toAuditEventInput", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.toAuditEventInput; }
+});
+Object.defineProperty(exports, "validatePolicyPack", {
+  enumerable: true,
+  get: function () { return chunk7VBKRGIZ_cjs.validatePolicyPack; }
+});
+Object.defineProperty(exports, "evaluateJsonLogic", {
+  enumerable: true,
+  get: function () { return chunk356N4NPM_cjs.evaluateJsonLogic; }
+});
+Object.defineProperty(exports, "matchesRule", {
+  enumerable: true,
+  get: function () { return chunk356N4NPM_cjs.matchesRule; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/policy/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ContentPolicyGate — the CONTENT axis of the ecosystem's legal/illegal system.
+ *
+ * "What may be SAID" — a provider-agnostic, jurisdiction-aware content-moderation
+ * gate with a pure-data ruleset. Compose it with the Twin Earth safety envelopes
+ * ("what may be DONE") and the conformance/founder gates ("where is it LAWFUL");
+ * all three write to the shared AuditLogger ledger.
+ *
+ * See research/2026-06-13 surface map + integration proposal.
+ */
+export * from './types';
+export * from './jsonLogic';
+export * from './blocklist';
+export * from './defaults';
+export * from './ContentPolicyGate';
+export * from './PolicyPack';
+//# sourceMappingURL=index.d.ts.map

package/dist/policy/index.js

@@ -0,0 +1,5 @@
+export { DEFAULT_BLOCKLIST, HARD_STOP_CATEGORIES, POLICY_PACK_COMPILE_TARGETS, POLICY_PACK_FRAMEWORK_IDS, PolicyPackDefinitionError, PolicyPackDeploymentError, assertPolicyPackDeploymentReady, buildContentPolicyConfig, defaultPolicyPackCompileTargets, defaultRulesForTier, definePolicyPack, evaluateContentPolicy, evaluateContentPolicySync, evaluatePolicyPackDeployment, isPolicyPackCompileTarget, isPolicyPackFrameworkId, jurisdictionBundle, matchBlocklist, normalizeText, policyPackFromSchemaBlock, toAuditEventInput, validatePolicyPack } from '../chunk-ET3AN4W3.js';
+export { evaluateJsonLogic, matchesRule } from '../chunk-JBQXZIWB.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/policy/jsonLogic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal, dependency-free JSON-Logic evaluator for the ContentPolicyGate ruleset.
+ *
+ * Policy rules are PURE DATA (JSON) — there is no code-execution surface — so a
+ * legal/illegal ruleset can live in a database or a per-jurisdiction file and be
+ * swapped WITHOUT a redeploy. That swap-without-deploy property (and the absence
+ * of an embedded interpreter) is the reason we use a small JSON-Logic subset here
+ * rather than pulling an OPA/Cedar runtime into the TS monorepo: the survey in
+ * research/2026-06-13 recommends rules-as-data for jurisdiction-varying policy,
+ * keeping a heavier engine as a later drop-in if scale demands it.
+ *
+ * This is intentionally NOT full JsonLogic. It supports exactly the operator
+ * subset the policy rules need, with a recursion-depth cap and a regex-length cap
+ * so a hostile rule file cannot hang the evaluator (ReDoS / stack blow-up).
+ */
+export type JsonLogicPrimitive = string | number | boolean | null;
+export type JsonLogicExpr = {
+    [operator: string]: unknown;
+};
+export type JsonLogicRule = JsonLogicPrimitive | JsonLogicExpr | JsonLogicRule[];
+/**
+ * Evaluate a JSON-Logic rule against a facts object. Returns the computed value
+ * (primitives evaluate to themselves; logic nodes evaluate their operator).
+ * Unknown operators and malformed nodes evaluate to `null` (falsy) rather than
+ * throwing — a broken rule fails CLOSED for `block` predicates because a `null`
+ * result is falsy, so it never silently allows.
+ */
+export declare function evaluateJsonLogic(rule: JsonLogicRule, data: Record<string, unknown>, depth?: number): unknown;
+/** Convenience: evaluate a rule and coerce the result to a boolean (truthy). */
+export declare function matchesRule(rule: JsonLogicRule, facts: Record<string, unknown>): boolean;
+//# sourceMappingURL=jsonLogic.d.ts.map

package/dist/policy/types.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Type surface for ContentPolicyGate — the ecosystem's "what may be SAID" gate.
+ *
+ * This is the CONTENT axis of the legal/illegal system (the other two axes —
+ * agent/robot ACTION legality and regulatory JURISDICTION — are enforced via the
+ * Twin Earth safety envelopes and the conformance/founder gates respectively; all
+ * three share this jurisdiction context and the audit ledger). See
+ * research/2026-06-13 surface map + integration proposal.
+ *
+ * Founder-anchored posture (2026-06-13):
+ *  - Rules are configurable data, default STRICT for the family tier.
+ *  - Jurisdiction is first-class from day one (GLOBAL launch target).
+ *  - The sovereign/Ollama lane is ALLOWED but every output routes through this
+ *    gate (the gate is provider-agnostic — it does not care which lane produced
+ *    the text), so the unaligned-model exposure is covered.
+ */
+import type { JsonLogicRule } from './jsonLogic';
+/** Policy-relevant content taxonomy. `none` = nothing actionable detected. */
+export type ContentCategory = 'csam' | 'sexual_minors' | 'terrorism' | 'self_harm' | 'violence' | 'weapons' | 'illegal_goods' | 'hate' | 'harassment' | 'sexual' | 'malware' | 'privacy' | 'misinformation' | 'none';
+/** EU AI Act risk tiers (Art. 6 / Annex III). */
+export type RiskTier = 'prohibited' | 'high' | 'limited' | 'minimal';
+/**
+ * Audience / surface strictness tier — the "configurable, start strict" knob.
+ * `family` is the strictest (HoloLand / schools, per D.079).
+ */
+export type PolicyTier = 'family' | 'teen' | 'general' | 'adult' | 'dev';
+/** IEEE 2089.1-2024 age-assurance confidence levels. */
+export type AgeAssurance = 'asserted' | 'standard' | 'enhanced' | 'strict';
+/** Enforcement verb a tier or rule can produce. Ranked block > escalate > flag > allow. */
+export type PolicyAction = 'allow' | 'flag' | 'escalate' | 'block';
+/**
+ * Where the content will be delivered — drives the legal obligations that apply.
+ * Resolved at request ingress (geo-IP is advisory, user-declared region preferred);
+ * stored as data so a legal team can update thresholds without a redeploy.
+ */
+export interface JurisdictionContext {
+    /** ISO 3166-1 alpha-2 (e.g. 'US', 'DE'), or the pseudo-regions 'EU' / 'GLOBAL'. */
+    region: string;
+    /** EU AI Act classification of the generating capability. */
+    aiActTier?: RiskTier;
+    /** EU Digital Services Act illegal-content obligations apply in this region. */
+    dsaApplies?: boolean;
+    /** Applicable minimum age for the surface in this region. */
+    minAge?: number;
+    /** Confidence we have in the user's declared age. */
+    ageAssurance?: AgeAssurance;
+    /**
+     * EU AI Act Art. 50-52 — generated/synthetic origin must be disclosed to the
+     * user (e.g. an NPC must reveal it is AI). Surfaced on the decision so the
+     * caller can render the disclosure; not itself a block.
+     */
+    disclosureRequired?: boolean;
+}
+/** A single classifier verdict (Tier-0 blocklist, Tier-1 model, or Tier-2 LLM). */
+export interface Classification {
+    category: ContentCategory;
+    /** 0..1 — confidence/severity that the content is in `category`. */
+    severity: number;
+    source: 'blocklist' | 'classifier' | 'llm' | 'provider' | 'none';
+    rationale?: string;
+}
+/** Verdict shape returned by an injected LLM moderation hook (Tier-2). */
+export interface ModerationVerdict {
+    flagged: boolean;
+    categories: ContentCategory[];
+    /** 0..1 — maximum severity across flagged categories. */
+    severity: number;
+    rationale?: string;
+}
+/**
+ * Facts exposed to data-rules and provider hooks. Rules reference these by dot
+ * path via the `var` operator (e.g. `{ "==": [{ "var": "category" }, "sexual"] }`).
+ * Open-ended so callers can attach surface-specific facts a rule can match on.
+ */
+export interface PolicyEvalFacts {
+    text: string;
+    textLength: number;
+    /** Normalized (diacritics stripped, separators collapsed) for matching. */
+    normalizedText: string;
+    category: ContentCategory;
+    severity: number;
+    tier: PolicyTier;
+    region: string;
+    aiActTier: RiskTier | null;
+    minAge: number | null;
+    dsaApplies: boolean;
+    /** Calling surface, e.g. 'brittney', 'npc_dialogue', 'publish_zone', 'voice'. */
+    surface: string;
+    /** Whether we are screening a user PROMPT (`input`) or model OUTPUT (`output`). */
+    direction: 'input' | 'output';
+    [key: string]: unknown;
+}
+/** Tier-0 blocklist entry — deterministic, category-tagged, optionally hard-stop. */
+export interface BlocklistEntry {
+    id: string;
+    category: ContentCategory;
+    /** Exact normalized terms matched on word boundaries. */
+    terms?: string[];
+    /** Regex pattern strings (evaluated with the ReDoS-guarded matcher). */
+    patterns?: string[];
+    /** Severity assigned when this entry matches. Default 0.95. */
+    severity?: number;
+    /** A hard-stop match can never be overridden by a rule or tier. */
+    hardStop?: boolean;
+}
+/**
+ * A data-driven policy rule. Pure JSON — swappable per tier/jurisdiction without
+ * a redeploy. `when` is a JSON-Logic predicate over {@link PolicyEvalFacts}.
+ */
+export interface RuleDescriptor {
+    id: string;
+    description: string;
+    when: JsonLogicRule;
+    action: PolicyAction;
+    category?: ContentCategory;
+    appliesToTiers?: PolicyTier[];
+    /** ISO region codes, or 'EU' / 'GLOBAL'. Empty/absent = all regions. */
+    appliesToRegions?: string[];
+    /** Legal basis text for the DSA-style Statement of Reasons. */
+    legalBasis?: string;
+    /** EU AI Act article reference, for the compliance record. */
+    aiActArticle?: string;
+    /** Higher wins on conflict within the same action rank. Default 0. */
+    priority?: number;
+}
+/** Injected Tier-1 classifier (cheap ML). Core stays dependency-free; surfaces supply it. */
+export type ClassifierHook = (text: string, facts: PolicyEvalFacts) => Promise<Classification | null> | Classification | null;
+/** Injected Tier-2 LLM-with-policy moderation. */
+export type LlmModerationHook = (text: string, facts: PolicyEvalFacts) => Promise<ModerationVerdict> | ModerationVerdict;
+/** Configuration for one evaluation context (one tier + jurisdiction + ruleset). */
+export interface ContentPolicyConfig {
+    tier: PolicyTier;
+    rules: RuleDescriptor[];
+    jurisdiction: JurisdictionContext;
+    blocklist?: BlocklistEntry[];
+    /** Categories that ALWAYS hard-block, regardless of tier/jurisdiction/rules. */
+    hardStopCategories?: ContentCategory[];
+    /** Tier-1 cheap classifier (optional). */
+    classifier?: ClassifierHook;
+    /** Tier-2 LLM-with-policy moderation (optional). */
+    llm?: LlmModerationHook;
+    /** Severity at/above which the Tier-2 LLM is consulted for borderline content. Default 0.3. */
+    borderlineThreshold?: number;
+    /** If true, the Tier-2 LLM runs on every non-hard-stopped item (strict surfaces). Default false. */
+    alwaysConsultLlm?: boolean;
+}
+/** Input to a single gate evaluation. */
+export interface ContentPolicyInput {
+    text: string;
+    surface: string;
+    direction?: 'input' | 'output';
+    /** Extra facts (merged into {@link PolicyEvalFacts}) a rule may match on. */
+    facts?: Record<string, unknown>;
+}
+/** The decision returned by the gate. */
+export interface ContentPolicyDecision {
+    allowed: boolean;
+    action: PolicyAction;
+    tier: PolicyTier;
+    category: ContentCategory;
+    severity: number;
+    matchedRuleId: string | null;
+    reason: string;
+    classification: Classification;
+    jurisdiction: JurisdictionContext;
+    /** DSA-style machine-readable Statement of Reasons (set on block/flag/escalate). */
+    statementOfReasons: string | null;
+    /** EU AI Act Art. 50-52 — caller must surface an AI/synthetic-origin disclosure. */
+    disclosureRequired: boolean;
+    /** Which cascade tier decided: 0 blocklist, 1 rules/classifier, 2 LLM, 3 human, -1 default-allow. */
+    decidedAtTier: 0 | 1 | 2 | 3 | -1;
+    timestampMs: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/proof-composition/ProofCompositionLaw.d.ts

@@ -0,0 +1,93 @@
+/**
+ * ProofCompositionLaw — algebraic receipt composition (Paper 29, H2).
+ *
+ * Composes N `WrappedSolverResult` receipts into a `ComposedReceipt` that
+ * proves the conjunction of all constituent solver contracts. Five laws
+ * govern the composition; `verifyCompositionLaws` checks any receipt
+ * against all five.
+ *
+ * ## The five laws
+ *
+ * | Law | Name | Rule |
+ * |-----|------|------|
+ * | 1 | empty-identity | compose([]) → composedVerified:true, composedSchemaValid:null |
+ * | 2 | and-monotone | composedVerified = ∀c: c.contractVerified |
+ * | 3 | schema-null-coalescing-and | composedSchemaValid = null if all null; else ∀ non-null: true |
+ * | 4 | violation-union | allViolations = ⋃ c.clauseViolations |
+ * | 5 | flat-associativity | compose(compose(A,B).components, C) ≡ compose(A,B,C) |
+ *
+ * Law 5 is enforced by keeping composition flat — `flattenForRecompose` exposes
+ * the primitive that makes it structurally verifiable.
+ *
+ * ## Domain-neutrality
+ *
+ * No domain nouns appear here. This module only composes proof shapes;
+ * domain-specific solvers register their own contracts and schemas.
+ */
+import type { WrappedSolverResult, PluginClauseViolation, SchemaViolation } from '../plugin-solver-contract/PluginSolverContract';
+export declare const PROOF_COMPOSITION_LAWS: readonly ["empty-identity", "and-monotone", "schema-null-coalescing-and", "violation-union", "flat-associativity"];
+export type ProofCompositionLaw = (typeof PROOF_COMPOSITION_LAWS)[number];
+/**
+ * The algebraic receipt produced by `composeReceipts`.
+ *
+ * Carries the conjunction of all constituent solver contracts' verification
+ * state, the union of all violations, provenance, and a stable identity hash.
+ */
+export interface ComposedReceipt {
+    /** Constituent wrapped solver results (in input order). */
+    readonly components: ReadonlyArray<WrappedSolverResult<unknown>>;
+    /**
+     * True iff every component has `contractVerified: true` (Laws 1 + 2).
+     * Empty composition yields `true`.
+     */
+    readonly composedVerified: boolean;
+    /**
+     * Schema validation verdict over all components (Law 3):
+     * - `null`  → all components are freeform (no schema registered for any).
+     * - `true`  → at least one component has a schema; all non-null pass.
+     * - `false` → at least one component has a schema and it failed.
+     */
+    readonly composedSchemaValid: boolean | null;
+    /** Union of all clause violations across components (Law 4). */
+    readonly allViolations: ReadonlyArray<PluginClauseViolation>;
+    /** Union of all schema violations across components. */
+    readonly allSchemaViolations: ReadonlyArray<SchemaViolation>;
+    /** Deduplicated plugin ids contributing to this composition. */
+    readonly pluginIds: ReadonlyArray<string>;
+    /** Deduplicated contract ids contributing to this composition. */
+    readonly contractIds: ReadonlyArray<string>;
+    /**
+     * FNV-1a 32 hash of the composition's verification state (prefix `"fnv1a32:<8 hex>"`).
+     * Identical components with identical verification state → identical hash.
+     * Non-cryptographic — use `'secure'` hash-policy for on-chain anchoring.
+     */
+    readonly hash: string;
+}
+/**
+ * Compose N `WrappedSolverResult` receipts into one `ComposedReceipt`.
+ *
+ * All five composition laws are enforced by construction. Pass the result
+ * of `wrapSolverInContract` calls from multiple plugins to prove the
+ * conjunction of their solver contracts in a single receipt.
+ */
+export declare function composeReceipts(components: ReadonlyArray<WrappedSolverResult<unknown>>): ComposedReceipt;
+/**
+ * Flatten a `ComposedReceipt`'s components for re-composition with additional receipts.
+ *
+ * Structural proof of Law 5 (flat-associativity):
+ *   `composeReceipts(flattenForRecompose(ab, [c]))`
+ *   is verification-equivalent to
+ *   `composeReceipts([...ab.components, c])`.
+ */
+export declare function flattenForRecompose(composed: ComposedReceipt, additional?: ReadonlyArray<WrappedSolverResult<unknown>>): ReadonlyArray<WrappedSolverResult<unknown>>;
+/**
+ * Verify that a `ComposedReceipt` satisfies all five composition laws.
+ *
+ * Returns the names of violated laws. An empty array means the receipt
+ * is fully law-compliant. Useful in tests and receipt audit flows.
+ *
+ * Note: Law 1 (empty-identity) and Law 5 (flat-associativity) are enforced
+ * structurally by `composeReceipts`; only Laws 2–4 are checkable on an
+ * arbitrary receipt.
+ */
+export declare function verifyCompositionLaws(receipt: ComposedReceipt): ProofCompositionLaw[];

package/dist/proof-composition/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var chunkYAO4HPJL_cjs = require('../chunk-YAO4HPJL.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "PROOF_COMPOSITION_LAWS", {
+  enumerable: true,
+  get: function () { return chunkYAO4HPJL_cjs.PROOF_COMPOSITION_LAWS; }
+});
+Object.defineProperty(exports, "composeReceipts", {
+  enumerable: true,
+  get: function () { return chunkYAO4HPJL_cjs.composeReceipts; }
+});
+Object.defineProperty(exports, "flattenForRecompose", {
+  enumerable: true,
+  get: function () { return chunkYAO4HPJL_cjs.flattenForRecompose; }
+});
+Object.defineProperty(exports, "verifyCompositionLaws", {
+  enumerable: true,
+  get: function () { return chunkYAO4HPJL_cjs.verifyCompositionLaws; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/proof-composition/index.d.ts

@@ -0,0 +1 @@
+export * from './ProofCompositionLaw';

package/dist/proof-composition/index.js

@@ -0,0 +1,4 @@
+export { PROOF_COMPOSITION_LAWS, composeReceipts, flattenForRecompose, verifyCompositionLaws } from '../chunk-655FATJU.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/receipts/hash-policy.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Receipt Hash Policy — two-tier SSOT for all receipt payloads in @holoscript/core.
+ *
+ * ## Tiers
+ *
+ * | Tier       | Algorithm | Output length | When to use                                        |
+ * |------------|-----------|---------------|----------------------------------------------------|
+ * | `'fast'`   | FNV-1a 32 | 8 hex chars   | Non-adversarial, high-throughput, local receipts   |
+ * | `'secure'` | SHA-256   | 64 hex chars  | Chain-anchored, adversarial-peer, on-chain records |
+ *
+ * **Default is `'fast'`** — this matches the non-adversarial threat model that governs
+ * most simulation receipts (internal replay, developer tooling, local twin). Use
+ * `'secure'` when a receipt will be anchored on-chain (x402/CAEL base anchor) or
+ * shared across trust boundaries where collision resistance matters.
+ *
+ * ## Usage
+ *
+ *   import { hashReceiptPayload, RECEIPT_HASH_POLICY_DEFAULT } from './hash-policy';
+ *
+ *   // Fast path (DomainSimulationReceipt, internal receipts):
+ *   const tag = hashReceiptPayload(payload);         // uses 'fast'
+ *
+ *   // Secure path (chain-anchored receipts):
+ *   const tag = hashReceiptPayload(payload, 'secure');
+ *
+ * ## Format tags
+ *
+ * Both functions prefix the raw hex with a format tag so receipts are
+ * self-identifying even without the policy field:
+ *   `fast`   → `"fnv1a32:<8 hex>"`
+ *   `secure` → `"sha256:<64 hex>"`
+ *
+ * ## Rationale
+ *
+ * Prior to this file, the fnv1a32 implementation was duplicated:
+ *   - `packages/core/src/receipts/DomainSimulationReceipt.ts` (private local fn)
+ *   - `packages/engine/src/simulation/sha256.ts` (byte-domain variant)
+ *   - `packages/core/src/reconstruction/replayFingerprint.ts` (double-FNV, 16 chars)
+ *
+ * Those existing callers are left unchanged (they are locked by tests). All NEW
+ * receipt hashing should go through this module.
+ *
+ * See: research/2026-06-16_language-extension-roadmap.md §H1 hash-policy
+ *      packages/engine/src/simulation/sha256.ts (engine-level mode dispatch)
+ */
+/**
+ * The two tiers of receipt hashing.
+ * Match the engine's `HashMode` naming intent but kept independent
+ * so @holoscript/core does not import from @holoscript/engine.
+ */
+export type ReceiptHashPolicy = 'fast' | 'secure';
+/** Default policy: FNV-1a 32 — fast, non-adversarial, non-cryptographic. */
+export declare const RECEIPT_HASH_POLICY_DEFAULT: ReceiptHashPolicy;
+/**
+ * Hash a canonicalized receipt payload string using the specified policy.
+ *
+ * For `'fast'` (default): synchronous, returns a prefixed string immediately.
+ * For `'secure'`: returns a Promise — await it or use `hashReceiptPayloadAsync`.
+ *
+ * The output is always prefixed with the format tag so receipts are
+ * self-identifying: `"fnv1a32:<hex>"` or `"sha256:<hex>"`.
+ */
+export declare function hashReceiptPayload(canonicalized: string, policy?: 'fast'): string;
+export declare function hashReceiptPayload(canonicalized: string, policy: 'secure'): Promise<string>;
+/**
+ * Async variant — always returns a Promise regardless of policy tier.
+ * Useful in async contexts where the synchronous fast path is still valid.
+ */
+export declare function hashReceiptPayloadAsync(canonicalized: string, policy?: ReceiptHashPolicy): Promise<string>;
+/**
+ * Parse a format-tagged hash string produced by `hashReceiptPayload`.
+ * Returns `{ policy, hex }` or `null` if the tag is not recognized.
+ *
+ * Useful for receipt verification: infer the tier from the stored hash
+ * without requiring a separate `hashAlgorithm` field.
+ */
+export declare function parseReceiptHash(tagged: string): {
+    policy: ReceiptHashPolicy;
+    hex: string;
+} | null;
+/**
+ * Format-level consistency check: does the hash string's prefix match
+ * the expected policy? Used to detect mid-receipt policy tampering.
+ */
+export declare function receiptHashMatchesPolicy(tagged: string, policy: ReceiptHashPolicy): boolean;