@holoscript/core 8.0.8 → 8.0.10

package/dist/plugin-solver-contract/PluginSolverContract.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Plugin contract discipline bundle (H2).
+ *
+ * Three primitives that close the "freeform receipt" gap and give every plugin
+ * solver the same proof-carrying guarantees the engine's ContractedSimulation
+ * provides — without importing the engine or duplicating its machinery:
+ *
+ *   1. **PluginSolverContract** — declarative pre/inv/post clause declarations
+ *      (JSON-safe data, not functions). The manifest references one by
+ *      `manifest.solverContract: string`. Registered in `PluginSolverContractRegistry`.
+ *
+ *   2. **SolverReceiptSchemaRegistry** — maps receipt schema IDs to validator
+ *      functions. A plugin registers a schema; the engine validates solver output
+ *      before issuing a receipt. Without a registered schema the receipt is
+ *      labeled `freeform: true` (honest) — no silent pass-through.
+ *
+ *   3. **wrapSolverInContract** — wraps a plugin solver function so that:
+ *      - preconditions are checked before the solver runs,
+ *      - postconditions are checked after,
+ *      - output is validated against the registered receipt schema.
+ *      Returns a `WrappedSolverResult` that carries all violations + the
+ *      schema verdict — ready to feed into a `DomainSimulationReceipt`.
+ *
+ * ## Domain-neutrality
+ *
+ * No domain nouns appear here. Plugins supply their own clause IDs,
+ * descriptions, and validator logic. Core only provides the skeleton.
+ *
+ * ## Design alignment
+ *
+ * - `PluginContractClause.severity` mirrors `ContractClause.severity` in engine.
+ * - `PluginClauseViolation` mirrors `ClauseViolation` in engine.
+ * - `PluginClauseContext` is simpler than engine's `ClauseContext` — no
+ *   `getField`/`simTime` (those are engine-side FEM solver concepts). Plugin
+ *   clauses observe `config` (pre-solve) and `result` (post-solve).
+ */
+export type PluginClauseKind = 'precondition' | 'invariant' | 'postcondition';
+/**
+ * A single clause in a `PluginSolverContract`.
+ *
+ * Intentionally JSON-serializable: no function references. Evaluators
+ * (the actual booleans) are registered separately via
+ * `PluginSolverContractRegistry.registerEvaluator()`.
+ */
+export interface PluginContractClause {
+    /** Stable identifier — appears in violation records and the receipt witness. */
+    id: string;
+    kind: PluginClauseKind;
+    /** Human-readable description of what this clause asserts. */
+    description: string;
+    /** 'error' (default) blocks `contractVerified: true`; 'warning' does not. */
+    severity?: 'error' | 'warning';
+    /**
+     * For `'invariant'` clauses: evaluate every N solver steps. Default: 1.
+     * Ignored for preconditions / postconditions.
+     */
+    cadence?: number;
+}
+/**
+ * Declarative plugin solver contract — the plugin-scope equivalent of
+ * `ContractClause` sets in `SimulationContract`.
+ *
+ * JSON-serializable: `manifest.solverContract` references this by `id`.
+ */
+export interface PluginSolverContract {
+    /**
+     * Stable contract identifier. Must match `manifest.solverContract`.
+     * Convention: `"<pluginId>-v<N>"` (e.g., `"retail-ecommerce-v1"`).
+     */
+    id: string;
+    /** Plugin that owns this contract. Must match `manifest.id`. */
+    pluginId: string;
+    /** Optional human-readable summary of what this solver proves. */
+    description?: string;
+    /** Clauses checked before the solver runs. Failure aborts execution. */
+    preconditions: PluginContractClause[];
+    /** Clauses checked during each solver step. */
+    invariants: PluginContractClause[];
+    /** Clauses checked after the solver completes. */
+    postconditions: PluginContractClause[];
+}
+/**
+ * Read-only context supplied to a clause evaluator function.
+ *
+ * Simpler than engine's `ClauseContext` (no `getField`/`simTime`) — plugin
+ * clauses observe configuration (pre-solve) and solver output (post-solve).
+ */
+export interface PluginClauseContext<TConfig = Record<string, unknown>, TResult = unknown> {
+    /** Frozen solver configuration (always available). */
+    readonly config: Readonly<TConfig>;
+    /**
+     * Solver result — `undefined` for preconditions, populated for postconditions.
+     * Use optional chaining: `ctx.result?.fieldName`.
+     */
+    readonly result: Readonly<TResult> | undefined;
+    /** The owning plugin's manifest id. */
+    readonly pluginId: string;
+}
+/** Evaluator function type — returns true when the clause HOLDS. */
+export type PluginClauseEvaluator<TConfig = Record<string, unknown>, TResult = unknown> = (ctx: PluginClauseContext<TConfig, TResult>) => boolean;
+/** A single clause violation recorded by `wrapSolverInContract`. */
+export interface PluginClauseViolation {
+    clauseId: string;
+    kind: PluginClauseKind;
+    severity: 'error' | 'warning';
+    message: string;
+    pluginId: string;
+}
+/** A single schema validation failure. */
+export interface SchemaViolation {
+    field: string;
+    message: string;
+}
+/** Result of running a `ReceiptSchemaValidator`. */
+export interface SchemaValidationResult {
+    valid: boolean;
+    violations: SchemaViolation[];
+}
+/** Validates a solver's raw result object against a declared output shape. */
+export type ReceiptSchemaValidator = (result: unknown) => SchemaValidationResult;
+/** A registered receipt schema entry. */
+export interface SolverReceiptSchemaEntry {
+    /** Stable schema identifier. Must match `manifest.receiptSchema`. */
+    id: string;
+    /** Plugin that registered this schema. */
+    pluginId: string;
+    /** Optional description of what fields the schema expects. */
+    description?: string;
+    validate: ReceiptSchemaValidator;
+}
+/**
+ * Return type of a solver wrapped by `wrapSolverInContract`.
+ *
+ * Carry this into `DomainSimulationReceipt.resultSummary` (or a subtype):
+ * it records both the solver's native output AND the contract proof state.
+ */
+export interface WrappedSolverResult<TResult> {
+    /** Raw solver output. */
+    result: TResult;
+    /**
+     * True iff all error-severity preconditions and postconditions passed.
+     * Warning-severity violations don't flip this to false.
+     */
+    contractVerified: boolean;
+    /**
+     * Result of schema validation.
+     * - `true`  → schema registered and validation passed.
+     * - `false` → schema registered but validation failed.
+     * - `null`  → no schema registered (freeform; manifest.receiptSchema absent).
+     */
+    schemaValid: boolean | null;
+    /** Schema ID that was used (null when freeform). */
+    schemaId: string | null;
+    /** All clause violations (error + warning). */
+    clauseViolations: PluginClauseViolation[];
+    /** Schema validation violations (empty when schemaValid !== false). */
+    schemaViolations: SchemaViolation[];
+    /** Contract ID applied to this result (null when no contract). Provenance for ComposedReceipt. */
+    contractId: string | null;
+    /** Plugin that owns the contract (null when no contract). Provenance for ComposedReceipt. */
+    pluginId: string | null;
+}
+/**
+ * Registry of `PluginSolverContract` declarations and their associated
+ * clause evaluators.
+ *
+ * Plugins call `registerContract()` during plugin registration (before scene
+ * init) to declare what their solver proves. `wrapSolverInContract` consults
+ * this registry at call time.
+ */
+export declare class PluginSolverContractRegistry {
+    private readonly contracts;
+    private readonly evaluators;
+    /**
+     * Register a solver contract declaration.
+     *
+     * @throws If a contract with the same `id` is already registered by a
+     *         different plugin.
+     */
+    registerContract(contract: PluginSolverContract): void;
+    /**
+     * Register a clause evaluator function for a specific clause within a contract.
+     *
+     * @param contractId  The contract's `id`.
+     * @param clauseId    The clause's `id` within that contract.
+     * @param evaluator   Returns true when the clause holds.
+     */
+    registerEvaluator(contractId: string, clauseId: string, evaluator: PluginClauseEvaluator): void;
+    /** Look up a registered contract by id. Returns undefined if not found. */
+    getContract(id: string): PluginSolverContract | undefined;
+    /** Look up a clause evaluator. Returns undefined if not registered. */
+    getEvaluator(contractId: string, clauseId: string): PluginClauseEvaluator | undefined;
+    /** All registered contracts (for introspection). */
+    allContracts(): ReadonlyArray<PluginSolverContract>;
+    /** Count of registered contracts. */
+    get size(): number;
+}
+/**
+ * Registry of receipt schema validators.
+ *
+ * Plugins call `registerSchema()` to declare the expected shape of their
+ * solver output. The engine validates `result` against the schema before
+ * issuing a receipt. A solver without a registered schema emits a receipt
+ * marked `freeform: true` — no silent pass.
+ */
+export declare class SolverReceiptSchemaRegistry {
+    private readonly schemas;
+    /**
+     * Register a receipt schema.
+     *
+     * @throws If a schema with the same `id` is registered by a different plugin.
+     */
+    registerSchema(entry: SolverReceiptSchemaEntry): void;
+    /** Look up a schema by id. Returns undefined → caller labels receipt freeform. */
+    getSchema(id: string): SolverReceiptSchemaEntry | undefined;
+    /**
+     * Validate `result` against the schema registered under `schemaId`.
+     * Returns `null` if no schema is registered (freeform).
+     */
+    validate(schemaId: string, result: unknown): SchemaValidationResult | null;
+    /** All registered schemas (for introspection). */
+    allSchemas(): ReadonlyArray<SolverReceiptSchemaEntry>;
+    /** Count of registered schemas. */
+    get size(): number;
+}
+/** Global contract registry — one table per process. */
+export declare const globalContractRegistry: PluginSolverContractRegistry;
+/** Global schema registry — one table per process. */
+export declare const globalSchemaRegistry: SolverReceiptSchemaRegistry;
+/**
+ * Register a plugin solver contract into the global registry.
+ *
+ * Call during plugin registration alongside `registerPluginTraits`.
+ */
+export declare function registerPluginContract(contract: PluginSolverContract): void;
+/**
+ * Register a clause evaluator for a contract clause into the global registry.
+ *
+ * @example
+ * ```ts
+ * registerContractClauseEvaluator('retail-ecommerce-v1', 'positive_demand', (ctx) => {
+ *   const cfg = ctx.config as { annualDemand?: number };
+ *   return typeof cfg.annualDemand === 'number' && cfg.annualDemand > 0;
+ * });
+ * ```
+ */
+export declare function registerContractClauseEvaluator(contractId: string, clauseId: string, evaluator: PluginClauseEvaluator): void;
+/**
+ * Register a receipt schema into the global schema registry.
+ *
+ * @example
+ * ```ts
+ * registerReceiptSchema({
+ *   id: 'retail-ecommerce-receipt-v1',
+ *   pluginId: 'retail-ecommerce',
+ *   description: 'EOQ result shape',
+ *   validate: (result) => {
+ *     const r = result as Record<string, unknown>;
+ *     const violations = [];
+ *     if (typeof r?.eoq !== 'number' || r.eoq <= 0)
+ *       violations.push({ field: 'eoq', message: 'must be a positive number' });
+ *     return { valid: violations.length === 0, violations };
+ *   },
+ * });
+ * ```
+ */
+export declare function registerReceiptSchema(entry: SolverReceiptSchemaEntry): void;
+/**
+ * Wrap a plugin solver function with contract + schema enforcement.
+ *
+ * The returned function:
+ *   1. Checks registered preconditions against `config`. Aborts with a
+ *      `WrappedSolverResult` (result: undefined, contractVerified: false) if
+ *      any error-severity precondition fires — the solver never runs.
+ *   2. Runs the solver.
+ *   3. Checks registered postconditions against `{ config, result }`.
+ *   4. Validates `result` against the registered receipt schema (if any).
+ *   5. Returns `WrappedSolverResult` carrying all violations + the schema verdict.
+ *
+ * @param solver      The raw plugin solver function.
+ * @param contractId  Contract id to look up in `globalContractRegistry`.
+ *                    If not registered the solver runs unguarded (no clauses).
+ * @param schemaId    Receipt schema id to look up in `globalSchemaRegistry`.
+ *                    If omitted or unregistered, `schemaValid: null` (freeform).
+ * @param registry    Contract registry to use (defaults to `globalContractRegistry`).
+ * @param schemaReg   Schema registry to use (defaults to `globalSchemaRegistry`).
+ */
+export declare function wrapSolverInContract<TConfig extends Record<string, unknown>, TResult>(solver: (config: TConfig) => TResult, contractId: string | undefined, schemaId: string | undefined, registry?: PluginSolverContractRegistry, schemaReg?: SolverReceiptSchemaRegistry): (config: TConfig) => WrappedSolverResult<TResult>;

package/dist/plugin-solver-contract/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var chunkECUYJOJ2_cjs = require('../chunk-ECUYJOJ2.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "PluginSolverContractRegistry", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.PluginSolverContractRegistry; }
+});
+Object.defineProperty(exports, "SolverReceiptSchemaRegistry", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.SolverReceiptSchemaRegistry; }
+});
+Object.defineProperty(exports, "globalContractRegistry", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.globalContractRegistry; }
+});
+Object.defineProperty(exports, "globalSchemaRegistry", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.globalSchemaRegistry; }
+});
+Object.defineProperty(exports, "registerContractClauseEvaluator", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.registerContractClauseEvaluator; }
+});
+Object.defineProperty(exports, "registerPluginContract", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.registerPluginContract; }
+});
+Object.defineProperty(exports, "registerReceiptSchema", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.registerReceiptSchema; }
+});
+Object.defineProperty(exports, "wrapSolverInContract", {
+  enumerable: true,
+  get: function () { return chunkECUYJOJ2_cjs.wrapSolverInContract; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/plugin-solver-contract/index.d.ts

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

package/dist/plugin-solver-contract/index.js

@@ -0,0 +1,4 @@
+export { PluginSolverContractRegistry, SolverReceiptSchemaRegistry, globalContractRegistry, globalSchemaRegistry, registerContractClauseEvaluator, registerPluginContract, registerReceiptSchema, wrapSolverInContract } from '../chunk-NJSYWX7H.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/policy/ContentPolicyGate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ContentPolicyGate — the shared "what may be SAID" gate for the ecosystem.
+ *
+ * Runs the four-tier moderation cascade recommended by the 2026-06-13 survey:
+ *   Tier 0  deterministic blocklist (hard-stops, sub-ms)
+ *   Tier 1  cheap classifier (optional, injected) + data rules
+ *   Tier 2  LLM-with-policy for borderline content (optional, injected)
+ *   Tier 3  human escalation (the `escalate` action — caller wires HITLManager)
+ *
+ * It is PROVIDER-AGNOSTIC by design: it does not know or care whether the text
+ * came from the Anthropic, OpenAI, or sovereign/Ollama lane. That is what lets
+ * the sovereign lane be "allowed but wrapped" — its output is screened by the
+ * same gate as everyone else's. Tier-1/Tier-2 model calls are injected hooks so
+ * @holoscript/core stays dependency-free; the studio/mcp-server surfaces supply
+ * the concrete moderation callables.
+ *
+ * Every decision is designed to flow into the existing audit ledger
+ * ({@link AuditLogger}) as a DSA-style Statement of Reasons via
+ * {@link toAuditEventInput} — so ComplianceReporter finally has real input.
+ */
+import type { AuditEventInput } from '../audit';
+import type { ContentPolicyConfig, ContentPolicyDecision, ContentPolicyInput } from './types';
+/**
+ * Run only the deterministic tiers (Tier-0 blocklist + data rules). Synchronous,
+ * no model calls — safe for hot paths and for callers that have no providers
+ * wired. The sovereign/Ollama lane can use this as a first-pass even before a
+ * Tier-2 LLM is available.
+ */
+export declare function evaluateContentPolicySync(input: ContentPolicyInput, config: ContentPolicyConfig): ContentPolicyDecision;
+/**
+ * Full async cascade: Tier-0 blocklist, Tier-1 classifier + data rules, Tier-2
+ * LLM-with-policy for borderline content, Tier-3 human escalation. Hard-stop
+ * categories short-circuit to a block at whatever tier first detects them.
+ */
+export declare function evaluateContentPolicy(input: ContentPolicyInput, config: ContentPolicyConfig): Promise<ContentPolicyDecision>;
+/** Context the audit ledger needs that the decision itself does not carry. */
+export interface AuditContext {
+    tenantId: string;
+    actorId: string;
+    actorType?: 'user' | 'agent' | 'system';
+    surface?: string;
+    resourceId?: string;
+    clientIp?: string;
+}
+/**
+ * Map a gate decision to an {@link AuditEventInput} for the existing AuditLogger.
+ * Produces a DSA-style machine-readable Statement-of-Reasons record. Pipe the
+ * result through `auditLogger.log(...)` at the call site.
+ */
+export declare function toAuditEventInput(decision: ContentPolicyDecision, ctx: AuditContext): AuditEventInput;
+//# sourceMappingURL=ContentPolicyGate.d.ts.map

package/dist/policy/PolicyPack.d.ts

@@ -0,0 +1,120 @@
+/**
+ * PolicyPack - named regulatory bundle for regulated AI deployment gates.
+ *
+ * A policy pack is data: it names the regulatory framework posture, the
+ * FairnessSweep evidence required before deploy, the compliance artifacts the
+ * compiler must emit, and the audit/monitoring obligations that must be armed.
+ */
+export declare const POLICY_PACK_FRAMEWORK_IDS: readonly ["EU_AI_ACT_HIGH_RISK", "NIST_AI_RMF", "ISO_42001", "CFPB_FAIR_LENDING", "NYC_LL144", "EEOC", "COLORADO_SB21_169"];
+export type PolicyPackFrameworkId = (typeof POLICY_PACK_FRAMEWORK_IDS)[number];
+export declare const POLICY_PACK_COMPILE_TARGETS: readonly ["bias_audit_report", "model_card", "impact_assessment", "declaration_of_conformity"];
+export type PolicyPackCompileTarget = (typeof POLICY_PACK_COMPILE_TARGETS)[number];
+declare const POLICY_PACK_MONITORING_INTERVALS: readonly ["per_deploy", "daily", "weekly", "monthly", "quarterly", "annual"];
+export type PolicyPackMonitoringInterval = (typeof POLICY_PACK_MONITORING_INTERVALS)[number];
+export interface RequiredFairnessSweep {
+    /** Stable test id. Deployment evidence must reference this id. */
+    id: string;
+    /** Protected attribute label passed to FairnessSweep. */
+    protectedAttribute: string;
+    /** Optional cohort floor for the submitted receipt. */
+    minSampleSize?: number;
+    /** Default regulatory four-fifths floor is 0.8 when omitted by callers. */
+    adverseImpactRatioMin?: number;
+    /** Optional upper bound for demographic parity difference. */
+    demographicParityDiffMax?: number;
+    /** Require a fairness.robustness.v1 receipt alongside the point estimate. */
+    requireRobustnessReceipt?: boolean;
+    /** Extra sweep config that a domain bridge may pass through to FairnessSweep. */
+    config?: Record<string, unknown>;
+}
+export interface PolicyPackAuditRetentionPolicy {
+    /** Minimum retention period for receipts and artifacts. */
+    minDays: number;
+    storage: 'append_only' | 'immutable_ledger' | 'external_archive';
+    legalHold?: boolean;
+}
+export interface PolicyPackMonitoringCadence {
+    interval: PolicyPackMonitoringInterval;
+    driftSweepRequired?: boolean;
+    alertThreshold?: number;
+}
+export interface PolicyPack {
+    type: 'PolicyPack';
+    name: string;
+    version: string;
+    frameworkId: PolicyPackFrameworkId;
+    requiredTests: RequiredFairnessSweep[];
+    requiredCompileTargets: PolicyPackCompileTarget[];
+    auditRetention: PolicyPackAuditRetentionPolicy;
+    monitoringCadence: PolicyPackMonitoringCadence;
+    controlsMapping?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+export type PolicyPackIssueCode = 'invalid_framework' | 'invalid_compile_target' | 'missing_required_test' | 'failed_required_test' | 'missing_compile_target' | 'audit_retention_not_armed' | 'monitoring_not_scheduled' | 'invalid_pack';
+export interface PolicyPackGateIssue {
+    code: PolicyPackIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    testId?: string;
+    compileTarget?: PolicyPackCompileTarget | string;
+}
+export interface PolicyPackTestEvidence {
+    id: string;
+    passed: boolean;
+    receiptHash?: string;
+    sampleSize?: number;
+    adverseImpactRatio?: number;
+    demographicParityDiff?: number;
+    robustnessReceiptHash?: string;
+}
+export interface PolicyPackCompileArtifact {
+    target: PolicyPackCompileTarget;
+    artifactId: string;
+    contentHash?: string;
+    generatedAt?: string;
+}
+export interface PolicyPackDeploymentEvidence {
+    tests: PolicyPackTestEvidence[];
+    compileTargets: PolicyPackCompileArtifact[];
+    auditRetentionAccepted?: boolean;
+    monitoringScheduled?: boolean;
+}
+export interface PolicyPackDeploymentEvaluation {
+    allowed: boolean;
+    policyPack: string;
+    frameworkId: PolicyPackFrameworkId;
+    missingTests: string[];
+    failedTests: string[];
+    missingCompileTargets: PolicyPackCompileTarget[];
+    issues: PolicyPackGateIssue[];
+}
+export interface PolicyPackSchemaBlock {
+    name: string;
+    version?: string;
+    frameworkId?: string;
+    requiredTests?: unknown[];
+    requiredCompileTargets?: unknown[];
+    auditRetention?: Record<string, unknown>;
+    monitoringCadence?: Record<string, unknown>;
+    properties?: Record<string, unknown>;
+}
+export declare class PolicyPackDeploymentError extends Error {
+    readonly evaluation: PolicyPackDeploymentEvaluation;
+    constructor(evaluation: PolicyPackDeploymentEvaluation);
+}
+export declare class PolicyPackDefinitionError extends Error {
+    readonly issues: PolicyPackGateIssue[];
+    constructor(issues: PolicyPackGateIssue[]);
+}
+export declare function isPolicyPackFrameworkId(value: string): value is PolicyPackFrameworkId;
+export declare function isPolicyPackCompileTarget(value: string): value is PolicyPackCompileTarget;
+export declare function validatePolicyPack(pack: PolicyPack): PolicyPackGateIssue[];
+export declare function definePolicyPack(input: Omit<PolicyPack, 'type'> & {
+    type?: 'PolicyPack';
+}): PolicyPack;
+export declare function policyPackFromSchemaBlock(block: PolicyPackSchemaBlock): PolicyPack;
+export declare function evaluatePolicyPackDeployment(pack: PolicyPack, evidence: PolicyPackDeploymentEvidence): PolicyPackDeploymentEvaluation;
+export declare function assertPolicyPackDeploymentReady(pack: PolicyPack, evidence: PolicyPackDeploymentEvidence): PolicyPackDeploymentEvaluation;
+export declare function defaultPolicyPackCompileTargets(): PolicyPackCompileTarget[];
+export {};
+//# sourceMappingURL=PolicyPack.d.ts.map

package/dist/policy/blocklist.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tier-0 of the content-moderation cascade: deterministic, sub-millisecond
+ * blocklist matching. This is the "hard stop, never probabilistic" layer — for
+ * the gravest categories (CSAM, sexualization of minors, terrorism) a match is a
+ * binary block, not a score.
+ *
+ * IMPORTANT — this module ships the STRUCTURE and a conservative starter set, not
+ * a production corpus. The authoritative Tier-0 detectors are external feeds that
+ * are deliberately NOT embedded in the repo:
+ *   - CSAM / sexual_minors  -> perceptual-hash feeds (PhotoDNA / NCMEC); text
+ *     heuristics here are a backstop only, never the primary detector.
+ *   - terrorism             -> GIFCT-style hash sharing.
+ * Wire those feeds in via {@link ContentPolicyConfig.blocklist} at deploy time.
+ * The bulk of nuanced text classification is intentionally left to the Tier-2 LLM;
+ * Tier-0 only catches unambiguous, evasion-normalized signals.
+ */
+import type { BlocklistEntry, Classification } from './types';
+/**
+ * Normalize text for matching: lower-case, strip diacritics, fold common
+ * homoglyph/leetspeak/separator evasion (e.g. "b.o.m.b", "h4te"), collapse
+ * whitespace. Used so blocklist terms survive trivial obfuscation.
+ */
+export declare function normalizeText(input: string): string;
+/**
+ * Run the Tier-0 blocklist over `text`. Returns the highest-severity match, or
+ * `null` if nothing matched. Hard-stop matches are returned with severity 1.
+ */
+export declare function matchBlocklist(text: string, entries: BlocklistEntry[]): (Classification & {
+    entryId: string;
+    hardStop: boolean;
+}) | null;
+//# sourceMappingURL=blocklist.d.ts.map

package/dist/policy/defaults.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Default rulesets, jurisdiction bundles, and the starter Tier-0 blocklist for
+ * ContentPolicyGate. All of this is DATA — a deployment can replace any of it
+ * without code changes. Posture (founder-anchored 2026-06-13): strict family
+ * default, global jurisdiction from day one.
+ */
+import type { BlocklistEntry, ContentCategory, ContentPolicyConfig, JurisdictionContext, PolicyTier, RuleDescriptor } from './types';
+/**
+ * Categories that ALWAYS hard-block regardless of tier, jurisdiction, or rules.
+ * These are illegal in effectively every jurisdiction and are never balanced
+ * against context. Detection for these is primarily external hash feeds.
+ */
+export declare const HARD_STOP_CATEGORIES: ContentCategory[];
+/**
+ * Starter Tier-0 blocklist. Structural + a conservative set of unambiguous
+ * instructional-harm patterns. The grave categories declare their entry so the
+ * hard-stop pipeline is wired, but their real detectors are external feeds — the
+ * in-repo matchers are deliberately empty (see blocklist.ts header).
+ */
+export declare const DEFAULT_BLOCKLIST: BlocklistEntry[];
+/**
+ * Resolve a jurisdiction bundle from a region code. Stored as data so legal
+ * thresholds can change without a redeploy. Unknown regions fall back to the
+ * strictest (GLOBAL) posture — fail strict, not open.
+ */
+export declare function jurisdictionBundle(region: string): JurisdictionContext;
+/** Compose the default ruleset for a tier. `dev` gets the floor only. */
+export declare function defaultRulesForTier(tier: PolicyTier): RuleDescriptor[];
+export interface BuildConfigOptions {
+    tier: PolicyTier;
+    /** ISO region / 'EU' / 'GLOBAL'. Default 'GLOBAL' (strictest). */
+    region?: string;
+    rules?: RuleDescriptor[];
+    blocklist?: BlocklistEntry[];
+    classifier?: ContentPolicyConfig['classifier'];
+    llm?: ContentPolicyConfig['llm'];
+}
+/**
+ * Build a ready-to-use config with sane, founder-anchored defaults: strict for
+ * family (lower borderline threshold + always consult the LLM when one is
+ * provided), global jurisdiction, hard-stop categories always enforced.
+ */
+export declare function buildContentPolicyConfig(opts: BuildConfigOptions): ContentPolicyConfig;
+//# sourceMappingURL=defaults.d.ts.map