@openlup/core 0.12.0 → 0.13.1

package/AGENTS.md

@@ -27,6 +27,9 @@ process: an application binds its ports and composes it.
 | `./risk` | kernel | candidate |
 | `./shipping` | kernel | candidate |
 | `./subscription` | kernel | candidate |
+| `./outbox` | kernel | experimental |
+| `./readiness` | kernel | experimental |
+| `./standard-schema` | kernel | experimental |
 | `./testing` | testing | testing |
 
 Any version may change an export, and each change is recorded in
@@ -80,4 +83,21 @@ those before guessing at a contract.
 
 ## Readiness codes
 
-This version raises no `OPENLUP_E_*` readiness code.
+The checker reports `OPENLUP_E_PORT_MISSING`, `OPENLUP_E_EVENT_UNHANDLED`,
+`OPENLUP_E_EVENT_DUPLICATE`, `OPENLUP_E_SCHEDULE_UNBOUND`, `OPENLUP_E_SCHEMA_BEHIND`,
+`OPENLUP_E_SET_MISMATCH` and `OPENLUP_E_ENV_MISSING`. Only a `ready` report admits
+its exact candidate. A host must provide complete installed metadata and selected-adapter
+observations; a report does not prove ACL, function bodies or recovery.
+
+## Using this package in an application
+
+- **Do not edit the installed package.** Do not change files under `node_modules/@openlup/`, and
+  do not patch it with `patch-package`, `overrides` or a fork.
+- **Change behaviour through seams.** Use this package's ports and options and your application's
+  own composition. If a seam is missing, raise an upstream issue.
+- **Copying source is ejection.** Copying this package's source into your application makes the
+  copy yours, including its upgrades.
+- **Upgrade every `@openlup/*` package together,** after reading each changelog's `Migration:`
+  blocks.
+- **Inside the OpenLup monorepo,** where this package is a workspace, the repository's root
+  `AGENTS.md` governs instead.

package/CHANGELOG.md

@@ -8,6 +8,30 @@ SemVer promise.
 
 ## [Unreleased]
 
+## [0.13.1]
+
+- Publishable on the npm `latest` dist-tag as `0.13.1`, from tag
+  `openlup-core-v0.13.1`.
+
+- Republish the unchanged core API and implementation with the repaired outbox publication as the complete `0.13.1` package set.
+
+## [0.13.0]
+
+- Publishable on the npm `latest` dist-tag as `0.13.0`, from tag
+  `openlup-core-v0.13.0`.
+
+- Add experimental outbox envelope/handler descriptors, structural validation, job lease and candidate readiness contracts.
+- Check package inventory, event ownership/coverage, actual bindings and qualified schema observations before admitting a new candidate.
+
+Migration: existing exports remain; compose the selected rail and bind its schema probe before activation. Unknown observations refuse the new candidate and do not stop a serving version.
+
+
+### Changed
+
+- `AGENTS.md` gains a required "Using this package in an application" section: do not edit or
+  patch the installed package, change behaviour through its seams, and upgrade every
+  `@openlup/*` package together. `docs:check` refuses a guide without it.
+
 ## [0.12.0]
 
 ### Removed

package/README.md

@@ -3,7 +3,10 @@
 `@openlup/core` is the kernel of the `@openlup/*` package family: the
 framework-independent TypeScript contracts and logic for subscription and
 bundle commerce that the other packages and an application's composition read.
-Agents start with [AGENTS.md](AGENTS.md).
+Agents start with [AGENTS.md](AGENTS.md). Its "Using this package in an
+application" section, which `docs:check` requires, tells an application's agent
+not to edit or patch the installed package and to upgrade every `@openlup/*`
+package together.
 
 ## Channel and stability
 
@@ -18,6 +21,8 @@ Agents start with [AGENTS.md](AGENTS.md).
   each change is recorded in [the changelog](CHANGELOG.md). Pin an exact
   version and read the changelog when you upgrade.
 
+The experimental `./outbox`, `./standard-schema` and `./readiness` subpaths provide shared infrastructure contracts. `checkReadiness` evaluates inert contribution descriptors, the complete host-observed package set, actual host bindings (schedule/route function identity must match the contribution) and a bounded schema probe. It never migrates, leases or sends. Only `ready` admits a new candidate; `unknown` and `unsatisfied` leave the serving candidate in place. The host owns inventory completeness, immutable artifact/configuration/schema identity and admission at every work entrance. Catalog existence does not prove SQL bodies, permissions or provider recovery.
+
 ## Package Surface Maturity
 
 Every current export is an internal candidate, experimental kernel, or testing
@@ -40,6 +45,9 @@ promise.
 | `./risk` | kernel | candidate | `smoke/riskStandalone.test.ts` |
 | `./shipping` | kernel | candidate | `smoke/shippingStandalone.test.ts` |
 | `./subscription` | kernel | candidate | `smoke/subscriptionBundleStandalone.test.ts` |
+| `./outbox` | kernel | experimental | `smoke/outboxStandalone.test.ts` |
+| `./readiness` | kernel | experimental | `smoke/readinessStandalone.test.ts` |
+| `./standard-schema` | kernel | experimental | `smoke/standardSchemaStandalone.test.ts` |
 | `./testing` | testing | testing | `smoke/testingStandalone.test.ts` |
 
 `release-gates.json` records four distinct evidence classes:
@@ -52,9 +60,26 @@ promise.
 - `externalConsumerEvidence`: not yet evaluated; a first-party packed consumer
   remains package smoke, not external adoption.
 
-## Local verification
+## Use in an application
 
-From this package directory:
+From your application's root, with Node 24 and npm 11.19.0:
+
+```sh
+npm install --save-exact @openlup/core@0.12.0
+```
+
+Read the installed `AGENTS.md`, then compose the [typed wiring example](AGENTS.md#wiring-example)
+with your application's own ports and options. Inspect the shipped sources and
+declarations for the exact version you installed. A missing seam needs an
+upstream proposal under your application's submission authority; the dependency
+guide grants no permission to publish an issue or change your application.
+Keep every installed `@openlup/*` package on the same exact set version.
+
+## Local verification from source
+
+The following developer commands require a source checkout of this package;
+the npm tarball omits its development scripts and tests. From the source package
+directory:
 
 ```sh
 npm ci
@@ -63,10 +88,17 @@ npm run ci
 
 Focused proofs are `npm run api:check`, `npm run release:check`, and
 `npm run test:consumer`. The root test script skips this suite.
-
-Repository neutrality checks reuse the existing source scanner through
-[the tree counting interface](./scripts/neutrality-tree-counts.ts). This
-process interface reads JSON containing source paths, contents and a policy
+`npm run docs:check` requires relative links in shipped Markdown to resolve to
+files actually packed in the tarball; a target present only in source refuses.
+Ambiguous destinations refuse explicitly: use literal punctuation or
+percent-encoded filenames, with ASCII whitespace before an optional title.
+Raw ampersands, angle characters and Unicode whitespace in local destinations
+require a canonical rewrite rather than passing an incomplete link check.
+
+The [repository neutrality checks](https://github.com/openlup/openlup/blob/openlup-core-v0.12.0/CONTRIBUTING.md#development-preview-checks)
+reuse the source scanner through `./scripts/neutrality-tree-counts.ts` relative
+to this source package. This process interface reads JSON containing source paths,
+contents and a policy
 from standard input, then emits finding counts for each path. Shell sources
 retain the scanner's existing shell handling. The interface adds no package
 export and changes no matcher or kernel behavior.
@@ -74,7 +106,7 @@ export and changes no matcher or kernel behavior.
 Repository lint keeps this package's production source independent of configured
 provider SDKs and explicit industry contract names. Adopter adapters compose
 providers; generic ports can forward opaque extension data. See the
-[syntax scope and exceptions](https://github.com/openlup/openlup/blob/main/CONTRIBUTING.md#development-preview-checks).
+[syntax scope and exceptions](https://github.com/openlup/openlup/blob/openlup-core-v0.12.0/CONTRIBUTING.md#development-preview-checks).
 
 The repository checker also calls the UI neutrality counting process with
 `--counts-json` to count its existing patterns over the supplied sources. Running that checker without
@@ -90,6 +122,8 @@ neutrality evidence, not package activation or consumer compatibility evidence.
 
 ## Kernel Documentation
 
+<!-- openlup-doc-impact {"unit":"core","digest":"sha256-4cbbfc0be291fa6ce550be48f3dafb7c9db6f474d8679ea1f66f8fd2a9947a9a","reason":"The core manifest and own lockfile move from 0.13.0 to 0.13.1 as part of the complete recovery set. API snapshots, exports, dependency resolutions, runtime behavior and package gates are unchanged; no application composition or verification step changes."} -->
+
 - [`docs/SUBSCRIPTION_ENGINE.md`](docs/SUBSCRIPTION_ENGINE.md) — what the
   `./subscription` kernel owns, its deterministic-clock contract, the
   late-payment cycle-shift rule and its monotonic clamp, and how a host

package/dist/outbox/index.d.ts

@@ -0,0 +1,55 @@
+/** @beta Shared event envelope. Storage and execution policy belong to the rail. */
+export interface OutboxEventRow {
+    id: string;
+    created_at: string;
+    available_at: string;
+    processed_at: string | null;
+    aggregate_type: string;
+    aggregate_id: string;
+    event_type: string;
+    idempotency_key: string;
+    status: string;
+    attempts: number;
+    payload: Record<string, unknown>;
+    error: string | null;
+    metadata: Record<string, unknown>;
+}
+/** @beta */
+export type OutboxHandlerOutcome = {
+    kind: "processed";
+    detail?: Record<string, unknown>;
+} | {
+    kind: "retry";
+    reason: string;
+} | {
+    kind: "discard";
+    reason: string;
+    benign?: boolean;
+} | {
+    kind: "snooze";
+    reason: string;
+};
+/** @beta Phase observations are transient; never put payloads or credentials here. */
+export interface OutboxHandlerExecutionContext {
+    setPhase(phase: string): void;
+}
+/** @beta Inert registration shared by preflight and the run-bound builder. */
+export interface OutboxHandlerDescriptor {
+    readonly eventType: string;
+    readonly timeoutMs: number;
+}
+/** @beta Structural abort signal, shared by browser and server implementations. */
+export interface OutboxAbortSignal {
+    readonly aborted: boolean;
+    readonly reason: unknown;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+}
+/** @beta Effects must be idempotent and honor the abort signal. */
+export interface OutboxHandler<Signal extends OutboxAbortSignal = OutboxAbortSignal> extends OutboxHandlerDescriptor {
+    handle(row: OutboxEventRow, signal: Signal, execution?: OutboxHandlerExecutionContext): Promise<OutboxHandlerOutcome>;
+}
+export { PLATFORM_EVENT_VOCABULARY } from "./vocabulary.js";
+export type { EventVocabularyEntry } from "./vocabulary.js";

package/dist/outbox/index.js

@@ -0,0 +1 @@
+export { PLATFORM_EVENT_VOCABULARY } from "./vocabulary.js";

package/dist/outbox/vocabulary.d.ts

@@ -0,0 +1,7 @@
+/** @beta Vocabulary ownership is separate from consumer registration. */
+export interface EventVocabularyEntry {
+    eventType: string;
+    owner: string;
+}
+/** @beta Applications supply their complete ordered persisted vocabulary separately. */
+export declare const PLATFORM_EVENT_VOCABULARY: readonly EventVocabularyEntry[];

package/dist/outbox/vocabulary.js

@@ -0,0 +1,36 @@
+/** @beta Applications supply their complete ordered persisted vocabulary separately. */
+export const PLATFORM_EVENT_VOCABULARY = [
+    { eventType: "commerce.order_draft.created", owner: "@openlup/core" },
+    { eventType: "commerce.order.paid", owner: "@openlup/core" },
+    { eventType: "commerce.order.paid.email", owner: "@openlup/core" },
+    { eventType: "commerce.payment.failed", owner: "@openlup/core" },
+    { eventType: "commerce.checkout.expired", owner: "@openlup/core" },
+    { eventType: "commerce.order.canceled", owner: "@openlup/core" },
+    { eventType: "commerce.order.refunded", owner: "@openlup/core" },
+    { eventType: "commerce.shipment.dispatched", owner: "@openlup/core" },
+    { eventType: "commerce.shipment.delivered", owner: "@openlup/core" },
+    { eventType: "commerce.shipment.exception", owner: "@openlup/core" },
+    { eventType: "commerce.return.approved", owner: "@openlup/core" },
+    { eventType: "commerce.return.rejected", owner: "@openlup/core" },
+    { eventType: "commerce.order.review_request", owner: "@openlup/core" },
+    { eventType: "commerce.order.review_effects", owner: "@openlup/core" },
+    { eventType: "commerce.product.back_in_stock", owner: "@openlup/core" },
+    { eventType: "commerce.order_draft.abandoned.1h", owner: "@openlup/core" },
+    { eventType: "commerce.order_draft.abandoned.24h", owner: "@openlup/core" },
+    { eventType: "commerce.order_draft.abandoned.72h", owner: "@openlup/core" },
+    { eventType: "commerce.order.reorder_reminder", owner: "@openlup/core" },
+    { eventType: "commerce.checkout_recovery", owner: "@openlup/core" },
+    { eventType: "subscription.cancelled", owner: "@openlup/core" },
+    { eventType: "subscription.created", owner: "@openlup/core" },
+    { eventType: "subscription.activation_action_required", owner: "@openlup/core" },
+    { eventType: "subscription.pause_reminder_due", owner: "@openlup/core" },
+    { eventType: "subscription.paused", owner: "@openlup/core" },
+    { eventType: "subscription.resumed", owner: "@openlup/core" },
+    { eventType: "subscription.delivery_rescheduled", owner: "@openlup/core" },
+    { eventType: "subscription.cycle_skipped", owner: "@openlup/core" },
+    { eventType: "subscription.address_changed", owner: "@openlup/core" },
+    { eventType: "subscription.package_changed", owner: "@openlup/core" },
+    { eventType: "subscription.renewal_upcoming", owner: "@openlup/core" },
+    { eventType: "accounting.order.reversal_requested", owner: "@openlup/core" },
+    { eventType: "commerce.fulfillment.handed_over", owner: "@openlup/core" },
+];

package/dist/platform-runtime/index.d.ts

@@ -8,3 +8,4 @@ export { createPlatformBundleRegistry, platformEnvSchema, } from "./platformKern
 export type { CreatePlatformBundleRegistryInput, PlatformBundleDescriptor, PlatformBundleRegistry, PlatformBundleReadiness, PlatformEnv, PlatformEnvInput, } from "./platformKernel.js";
 /** @beta */
 export type { AnalyticsPort, BlobStoragePort, DataGatewayPort, HttpRuntimePort, MigrationRunnerPort, PlatformHttpRequest, PlatformHttpResponse, SchedulerPort, TransactionalRuntimePort, } from "./ports.js";
+export type { JobLeasePort, PlatformJobTriggerKind, PlatformJobInvocation, PlatformJobClaim, PlatformJobFinishStatus, PlatformJobFinishSummary } from "./ports.js";

package/dist/platform-runtime/ports.d.ts

@@ -98,3 +98,27 @@ export interface TransactionalRuntimePort {
         status: number;
     }>;
 }
+/** @beta Invocation evidence and claim/finish contract shared by infrastructure rails. */
+export type PlatformJobTriggerKind = "worker" | "scheduler" | "operator";
+export type PlatformJobInvocation = {
+    triggerKind: PlatformJobTriggerKind;
+    /** Observational adapter evidence; it never grants execution authority. */
+    invocationSource: string;
+};
+export type PlatformJobClaim = {
+    acquired: boolean;
+    runId: string | null;
+    reason: string;
+};
+export type PlatformJobFinishStatus = "success" | "failed";
+export type PlatformJobFinishSummary = {
+    checked: number;
+    updated: number;
+    failures: number;
+    skipped: boolean;
+    reason?: string;
+};
+export interface JobLeasePort {
+    claimJobRun(jobName: string, invocation: PlatformJobInvocation, leaseSeconds?: number): Promise<PlatformJobClaim>;
+    finishJobRun(jobName: string, runId: string, invocation: PlatformJobInvocation, status: PlatformJobFinishStatus, result: PlatformJobFinishSummary, extraMetadata?: Record<string, unknown>): Promise<boolean>;
+}

package/dist/readiness/contracts.d.ts

@@ -0,0 +1,121 @@
+import type { OutboxHandlerDescriptor } from "../outbox/index.js";
+import type { EventVocabularyEntry } from "../outbox/vocabulary.js";
+/** @beta */
+export declare const READINESS_CODES: readonly ["OPENLUP_E_PORT_MISSING", "OPENLUP_E_EVENT_UNHANDLED", "OPENLUP_E_EVENT_DUPLICATE", "OPENLUP_E_SCHEDULE_UNBOUND", "OPENLUP_E_SCHEMA_BEHIND", "OPENLUP_E_SET_MISMATCH", "OPENLUP_E_ENV_MISSING"];
+/** @beta */
+export type ReadinessCode = typeof READINESS_CODES[number];
+/** @beta */
+export interface ReadinessIssue {
+    code: ReadinessCode;
+    package: string;
+    subject: string;
+    fix: string;
+    observation?: string;
+}
+/** @beta */
+export interface SchemaObject {
+    kind: "table" | "column" | "function";
+    name: string;
+    signature?: string;
+}
+/** @beta Version is an adapter-specific migration identity, not inferred from object existence. */
+export interface RequiredSchema {
+    version: string;
+    migration: string;
+    objects: readonly SchemaObject[];
+}
+/** @beta */
+export interface PackageManifest {
+    name: string;
+    version: string;
+    kind: "kernel" | "rail" | "capability" | "implementation";
+    emits: readonly string[];
+    handles: readonly string[];
+    schedules: readonly {
+        id: string;
+        cadenceSeconds: number;
+    }[];
+    routes: readonly string[];
+    requiredPorts: readonly string[];
+    env: readonly string[];
+    requiredSchema?: RequiredSchema;
+}
+/** @beta Run-bound handlers are represented by their shared inert descriptors. */
+export interface Contribution {
+    manifest: PackageManifest;
+    handlers: readonly OutboxHandlerDescriptor[];
+    schedules: readonly {
+        id: string;
+        cadenceSeconds: number;
+        run: (...args: never[]) => unknown;
+    }[];
+    routes: readonly {
+        id: string;
+        handle: (...args: never[]) => unknown;
+    }[];
+}
+/** @beta Host-observed inventory, including core. The loader owns completeness. */
+export interface LoadedPackage {
+    name: string;
+    version: string;
+    kind: PackageManifest["kind"];
+}
+/** @beta Candidate identity must change when configuration, schema or artifact changes. */
+export interface CandidateIdentity {
+    artifact: string;
+    configuration: string;
+    environment: string;
+    database: string;
+    schema: string;
+}
+/** @beta */
+export interface EventExemption {
+    pattern: string;
+    prefix: boolean;
+    owner: string;
+    reason: string;
+    state: "ignored" | "dormant";
+}
+/** @beta */
+export interface ReadinessInput {
+    candidate: CandidateIdentity;
+    inventoryComplete: boolean;
+    loadedPackages: readonly LoadedPackage[];
+    contributions: readonly Contribution[];
+    vocabulary: readonly EventVocabularyEntry[];
+    exemptions: readonly EventExemption[];
+    bindings: {
+        ports: Readonly<Record<string, unknown>>;
+        triggers: Readonly<Record<string, unknown>>;
+        routes: Readonly<Record<string, unknown>>;
+        env: Readonly<Record<string, string | undefined>>;
+    };
+    schemaProbe: SchemaProbePort;
+    probeTimeoutMs?: number;
+}
+/** @beta A bounded catalog observation, not proof of SQL bodies, ACL or recovery. */
+export interface SchemaObservation {
+    database: string;
+    version: string | null;
+    objects: readonly {
+        object: SchemaObject;
+        present: boolean | null;
+    }[];
+}
+/** @beta */
+export interface SchemaProbePort {
+    observe(requirement: RequiredSchema): Promise<SchemaObservation>;
+}
+/** @beta Each operation commits before resolving; never lend a producer transaction to dispatch. */
+export interface SqlExecutor {
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(text: string, values?: readonly unknown[]): Promise<{
+        rows: Row[];
+    }>;
+}
+/** @beta */
+export interface ReadinessReport {
+    state: "ready" | "unsatisfied" | "unknown";
+    candidate: CandidateIdentity;
+    loadedPackages: readonly LoadedPackage[];
+    issues: readonly ReadinessIssue[];
+}

package/dist/readiness/contracts.js

@@ -0,0 +1,2 @@
+/** @beta */
+export const READINESS_CODES = ["OPENLUP_E_PORT_MISSING", "OPENLUP_E_EVENT_UNHANDLED", "OPENLUP_E_EVENT_DUPLICATE", "OPENLUP_E_SCHEDULE_UNBOUND", "OPENLUP_E_SCHEMA_BEHIND", "OPENLUP_E_SET_MISMATCH", "OPENLUP_E_ENV_MISSING"];

package/dist/readiness/declarations.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import type { ReadinessInput, ReadinessIssue } from "./contracts.js";
+export declare const schemaObjectShape: z.ZodObject<{
+    kind: z.ZodEnum<{
+        function: "function";
+        table: "table";
+        column: "column";
+    }>;
+    name: z.ZodString;
+    signature: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const manifestShape: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    kind: z.ZodEnum<{
+        kernel: "kernel";
+        rail: "rail";
+        capability: "capability";
+        implementation: "implementation";
+    }>;
+    emits: z.ZodArray<z.ZodString>;
+    handles: z.ZodArray<z.ZodString>;
+    schedules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        cadenceSeconds: z.ZodNumber;
+    }, z.core.$strict>>;
+    routes: z.ZodArray<z.ZodString>;
+    requiredPorts: z.ZodArray<z.ZodString>;
+    env: z.ZodArray<z.ZodString>;
+    requiredSchema: z.ZodOptional<z.ZodObject<{
+        version: z.ZodString;
+        migration: z.ZodString;
+        objects: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                function: "function";
+                table: "table";
+                column: "column";
+            }>;
+            name: z.ZodString;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Validate declarations without invoking a handler, schedule, route or probe. */
+export declare function declarationIssues(input: ReadinessInput): ReadinessIssue[];

package/dist/readiness/declarations.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+const name = z.string().min(1).max(240).regex(/^[a-zA-Z0-9@_./:-]+$/);
+const version = z.string().regex(/^0\.\d+\.\d+$/);
+const list = z.array(name).refine((items) => new Set(items).size === items.length);
+const kind = z.enum(["kernel", "rail", "capability", "implementation"]);
+export const schemaObjectShape = z.object({ kind: z.enum(["table", "column", "function"]), name,
+    signature: z.string().max(1000).optional() }).strict().refine((o) => o.name.split(".").length === (o.kind === "column" ? 3 : 2) && (o.kind !== "function" || o.signature !== undefined));
+export const manifestShape = z.object({ name: name.regex(/^@openlup\/[a-z0-9-]+$/), version, kind,
+    emits: list, handles: list, schedules: z.array(z.object({ id: name, cadenceSeconds: z.number().finite().positive() }).strict()),
+    routes: list, requiredPorts: list, env: list,
+    requiredSchema: z.object({ version: name, migration: name, objects: z.array(schemaObjectShape) }).strict().optional(),
+}).strict();
+/** Validate declarations without invoking a handler, schedule, route or probe. */
+export function declarationIssues(input) {
+    const issues = [];
+    const issue = (subject, fix, code = "OPENLUP_E_SET_MISMATCH") => issues.push({ code, package: "@openlup/core", subject, fix });
+    if (!input || typeof input !== "object") {
+        issue("input", "Supply complete candidate observations.");
+        return issues;
+    }
+    if (!input.candidate || ![input.candidate.artifact, input.candidate.configuration, input.candidate.environment, input.candidate.database, input.candidate.schema].every((v) => typeof v === "string" && /^[a-zA-Z0-9_.:/-]{1,240}$/.test(v)))
+        issue("candidate", "Supply sanitized immutable artifact, configuration, environment and database identities.");
+    if (input.inventoryComplete !== true)
+        issue("inventory", "Observe the complete installed package inventory, including core.");
+    if (!Array.isArray(input.loadedPackages) || !Array.isArray(input.contributions)) {
+        issue("inventory", "Supply loaded packages and contributions as arrays.");
+        return issues;
+    }
+    for (const pkg of input.loadedPackages)
+        if (!z.object({ name, version, kind }).strict().safeParse(pkg).success)
+            issue("loaded-package", "Supply a valid observed package name, version and kind.");
+    for (const c of input.contributions) {
+        if (!manifestShape.safeParse(c?.manifest).success) {
+            issue("manifest", "Supply a valid complete manifest with unique declarations.");
+            continue;
+        }
+        if (!Array.isArray(c.handlers) || c.handlers.some((h) => !name.safeParse(h?.eventType).success || !Number.isFinite(h?.timeoutMs) || h?.timeoutMs <= 0))
+            issue(c.manifest.name, "Supply valid shared handler descriptors.", "OPENLUP_E_EVENT_UNHANDLED");
+        if (!Array.isArray(c.schedules) || c.schedules.some((s) => !name.safeParse(s?.id).success || !Number.isFinite(s?.cadenceSeconds) || s?.cadenceSeconds <= 0 || typeof s?.run !== "function"))
+            issue(c.manifest.name, "Supply actual runnable schedules.", "OPENLUP_E_SCHEDULE_UNBOUND");
+        if (!Array.isArray(c.routes) || c.routes.some((r) => !name.safeParse(r?.id).success || typeof r?.handle !== "function"))
+            issue(c.manifest.name, "Supply actual route registrations.", "OPENLUP_E_PORT_MISSING");
+        const objects = c.manifest.requiredSchema?.objects ?? [];
+        if (new Set(objects.map((o) => `${o.kind}:${o.name}:${o.signature ?? ""}`)).size !== objects.length)
+            issue(c.manifest.name, "Remove duplicate schema requirements.", "OPENLUP_E_SCHEMA_BEHIND");
+    }
+    if (!Array.isArray(input.vocabulary) || input.vocabulary.some((v) => !name.safeParse(v?.eventType).success || !name.safeParse(v?.owner).success))
+        issue("vocabulary", "Supply explicit vocabulary entries with owners.", "OPENLUP_E_EVENT_UNHANDLED");
+    if (!Array.isArray(input.exemptions) || input.exemptions.some((e) => !name.safeParse(e?.pattern).success || typeof e?.prefix !== "boolean" || !name.safeParse(e?.owner).success || typeof e?.reason !== "string" || !e?.reason.trim() || !["ignored", "dormant"].includes(e?.state)))
+        issue("exemptions", "Supply explicit owned exemptions with reasons.", "OPENLUP_E_EVENT_UNHANDLED");
+    if (!input.bindings || [input.bindings.ports, input.bindings.routes, input.bindings.triggers, input.bindings.env].some((v) => !v || typeof v !== "object" || Array.isArray(v)))
+        issue("bindings", "Supply actual host bindings.", "OPENLUP_E_PORT_MISSING");
+    if (!input.schemaProbe || typeof input.schemaProbe.observe !== "function")
+        issue("schemaProbe", "Bind a schema observation port.", "OPENLUP_E_SCHEMA_BEHIND");
+    if (input.probeTimeoutMs !== undefined && (!Number.isFinite(input.probeTimeoutMs) || input.probeTimeoutMs < 1 || input.probeTimeoutMs > 30000))
+        issue("probeTimeoutMs", "Use a bounded probe timeout from 1 to 30000 ms.", "OPENLUP_E_SCHEMA_BEHIND");
+    return issues;
+}

package/dist/readiness/index.d.ts

@@ -0,0 +1,5 @@
+import type { ReadinessInput, ReadinessReport } from "./contracts.js";
+export * from "./contracts.js";
+export { schemaObjectKey, buildSchemaObjectProbe, createSchemaProbe } from "./schemaProbe.js";
+/** @beta Evaluates supplied facts; never performs migration or effect work. */
+export declare function checkReadiness(input: ReadinessInput): Promise<ReadinessReport>;