@aldus-runtime/release 0.1.0

package/dist/bundle.js

@@ -0,0 +1,67 @@
+/**
+ * Release bundles (architecture contract §17).
+ *
+ * A bundle is a **declaration**, not a record of what happened: contract §17 states that
+ * "publishing is a domain, not a single command", and the bundle is the domain's unit of intent.
+ * What happened lives in `ReleaseReceipt`s, one per operation, in the Run's `release.json`
+ * (§7).
+ *
+ * There is deliberately no persisted bundle state. Execution state is derived from the receipts
+ * on every inspection, for the same reason ADR-0009 derives gate state rather than storing it: a
+ * stored "in progress" flag survives a crash that the operation it describes did not, and an
+ * operator then reads a status that was true once and is not true now.
+ */
+import { createHash } from "node:crypto";
+import { ReleaseErrorCodes, releaseError } from "./errors.js";
+/** Every operation in a bundle, required first, in execution order. */
+export function operationsOf(bundle) {
+    return [...bundle.required, ...bundle.bestEffort];
+}
+/**
+ * Check a bundle's internal consistency.
+ *
+ * @throws {AldusError} `ALDUS_RELEASE_EMPTY_BUNDLE` if it declares no operations.
+ * @throws {AldusError} `ALDUS_RELEASE_DUPLICATE_OPERATION` if an `operationId` repeats.
+ */
+export function assertBundleValid(bundle) {
+    const operations = operationsOf(bundle);
+    if (operations.length === 0) {
+        throw releaseError(ReleaseErrorCodes.EMPTY_BUNDLE, `Release bundle "${bundle.bundleId}" declares no operations, so executing it would report ` +
+            "a successful release that published nothing.", { category: "validation", details: { bundleId: bundle.bundleId } });
+    }
+    const seen = new Set();
+    for (const operation of operations) {
+        if (seen.has(operation.operationId)) {
+            throw releaseError(ReleaseErrorCodes.DUPLICATE_OPERATION, `Release bundle "${bundle.bundleId}" declares "${operation.operationId}" twice. ` +
+                "Operation ids match receipts back to operations, so a duplicate would let one " +
+                "operation inherit the other's outcome.", {
+                category: "validation",
+                details: { bundleId: bundle.bundleId, operationId: operation.operationId },
+            });
+        }
+        seen.add(operation.operationId);
+    }
+}
+/**
+ * Derive the idempotency key for one operation (contract §17, §19.1).
+ *
+ * §17 requires each operation to be "independently idempotent and resumable where the platform
+ * allows it", and `ReleaseReceipt.idempotencyKey` is the mechanism. The key is **derived, not
+ * supplied**, from the bundle, the operation, its destination, and the digests of what it
+ * releases — so a resumed execution computes the identical key without having to remember one,
+ * and a changed input produces a different key rather than silently reusing an old outcome.
+ *
+ * Input hashes are sorted before digesting: the set of things released is what matters, not the
+ * order a caller happened to list them in.
+ */
+export function deriveIdempotencyKey(bundleId, operation) {
+    const material = JSON.stringify({
+        bundleId,
+        operationId: operation.operationId,
+        kind: operation.kind,
+        destination: operation.destination,
+        inputHashes: [...operation.inputHashes].sort(),
+    });
+    return createHash("sha256").update(material, "utf8").digest("hex");
+}
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAuB9D,uEAAuE;AACvE,MAAM,UAAU,YAAY,CAAC,MAAqB;IAChD,OAAO,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAqB;IACrD,MAAM,UAAU,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACxC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,YAAY,CAChB,iBAAiB,CAAC,YAAY,EAC9B,mBAAmB,MAAM,CAAC,QAAQ,yDAAyD;YACzF,8CAA8C,EAChD,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,EAAE,CACnE,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC;YACpC,MAAM,YAAY,CAChB,iBAAiB,CAAC,mBAAmB,EACrC,mBAAmB,MAAM,CAAC,QAAQ,eAAe,SAAS,CAAC,WAAW,WAAW;gBAC/E,gFAAgF;gBAChF,wCAAwC,EAC1C;gBACE,QAAQ,EAAE,YAAY;gBACtB,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW,EAAE;aAC3E,CACF,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB,EAAE,SAA2B;IAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;QAC9B,QAAQ;QACR,WAAW,EAAE,SAAS,CAAC,WAAW;QAClC,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,WAAW,EAAE,SAAS,CAAC,WAAW;QAClC,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE;KAC/C,CAAC,CAAC;IACH,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACrE,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Failures specific to release execution.
+ *
+ * Aldus Core deliberately keeps no central error-code registry, so that a package can name a new
+ * failure without forking Core. These codes are this package's contribution; they carry the same
+ * `ALDUS_` prefix and `SCREAMING_SNAKE_CASE` shape so production trace (contract §20) stays
+ * uniform across packages.
+ */
+import { AldusError, type ErrorCategory } from "@aldus-runtime/core";
+/** Error codes raised by the release executor. */
+export declare const ReleaseErrorCodes: {
+    /**
+     * An operation was attempted that no gate authorizes.
+     *
+     * Contract §13.4 binds release approval to the final render, captions, metadata, destination,
+     * and visibility policy, and §17 requires uploading and making public to be separate
+     * operations. An unauthorized release is refused rather than warned about: a warning that
+     * still publishes is not a gate.
+     */
+    readonly RELEASE_NOT_AUTHORIZED: "ALDUS_RELEASE_NOT_AUTHORIZED";
+    /** No adapter is registered for an operation's destination. */
+    readonly ADAPTER_NOT_REGISTERED: "ALDUS_RELEASE_ADAPTER_NOT_REGISTERED";
+    /** A bundle declared two operations with the same `operationId`. */
+    readonly DUPLICATE_OPERATION: "ALDUS_RELEASE_DUPLICATE_OPERATION";
+    /** A bundle was constructed with no operations at all. */
+    readonly EMPTY_BUNDLE: "ALDUS_RELEASE_EMPTY_BUNDLE";
+    /**
+     * A required operation failed, so the release did not complete.
+     *
+     * Distinct from a best-effort failure, which is recorded and does not fail the release
+     * (contract §17: "Pre-release hard gates and post-upload best-effort operations MUST be
+     * distinguished").
+     */
+    readonly REQUIRED_OPERATION_FAILED: "ALDUS_RELEASE_REQUIRED_OPERATION_FAILED";
+    /**
+     * A stored receipt disagrees with the bundle that produced it.
+     *
+     * The identity of an operation is its `operationId` plus its idempotency key. A receipt whose
+     * key no longer matches describes a different operation than the one about to run, and reusing
+     * it would let changed inputs inherit an old approval's outcome.
+     */
+    readonly RECEIPT_MISMATCH: "ALDUS_RELEASE_RECEIPT_MISMATCH";
+    /**
+     * Reconciliation was required but the adapter cannot look up remote state.
+     *
+     * Contract §17 requires operations to be resumable "where the platform allows it". Where it
+     * does not, the honest outcome is to say so rather than to re-execute and risk a duplicate
+     * publish.
+     */
+    readonly RECONCILIATION_UNAVAILABLE: "ALDUS_RELEASE_RECONCILIATION_UNAVAILABLE";
+};
+/** @see ReleaseErrorCodes */
+export type ReleaseErrorCode = (typeof ReleaseErrorCodes)[keyof typeof ReleaseErrorCodes];
+/** Construct an {@link AldusError} with a release code. */
+export declare function releaseError(code: ReleaseErrorCode, message: string, options: {
+    category: ErrorCategory;
+    retryable?: boolean;
+    details?: Record<string, unknown>;
+}): AldusError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAErE,kDAAkD;AAClD,eAAO,MAAM,iBAAiB;IAC5B;;;;;;;OAOG;aACH,sBAAsB,EAAE,8BAA8B;IACtD,+DAA+D;aAC/D,sBAAsB,EAAE,sCAAsC;IAC9D,oEAAoE;aACpE,mBAAmB,EAAE,mCAAmC;IACxD,0DAA0D;aAC1D,YAAY,EAAE,4BAA4B;IAC1C;;;;;;OAMG;aACH,yBAAyB,EAAE,yCAAyC;IACpE;;;;;;OAMG;aACH,gBAAgB,EAAE,gCAAgC;IAClD;;;;;;OAMG;aACH,0BAA0B,EAAE,0CAA0C;CAC9D,CAAC;AAEX,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAE1F,2DAA2D;AAC3D,wBAAgB,YAAY,CAC1B,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC3F,UAAU,CAEZ"}

package/dist/errors.js

@@ -0,0 +1,56 @@
+/**
+ * Failures specific to release execution.
+ *
+ * Aldus Core deliberately keeps no central error-code registry, so that a package can name a new
+ * failure without forking Core. These codes are this package's contribution; they carry the same
+ * `ALDUS_` prefix and `SCREAMING_SNAKE_CASE` shape so production trace (contract §20) stays
+ * uniform across packages.
+ */
+import { AldusError } from "@aldus-runtime/core";
+/** Error codes raised by the release executor. */
+export const ReleaseErrorCodes = {
+    /**
+     * An operation was attempted that no gate authorizes.
+     *
+     * Contract §13.4 binds release approval to the final render, captions, metadata, destination,
+     * and visibility policy, and §17 requires uploading and making public to be separate
+     * operations. An unauthorized release is refused rather than warned about: a warning that
+     * still publishes is not a gate.
+     */
+    RELEASE_NOT_AUTHORIZED: "ALDUS_RELEASE_NOT_AUTHORIZED",
+    /** No adapter is registered for an operation's destination. */
+    ADAPTER_NOT_REGISTERED: "ALDUS_RELEASE_ADAPTER_NOT_REGISTERED",
+    /** A bundle declared two operations with the same `operationId`. */
+    DUPLICATE_OPERATION: "ALDUS_RELEASE_DUPLICATE_OPERATION",
+    /** A bundle was constructed with no operations at all. */
+    EMPTY_BUNDLE: "ALDUS_RELEASE_EMPTY_BUNDLE",
+    /**
+     * A required operation failed, so the release did not complete.
+     *
+     * Distinct from a best-effort failure, which is recorded and does not fail the release
+     * (contract §17: "Pre-release hard gates and post-upload best-effort operations MUST be
+     * distinguished").
+     */
+    REQUIRED_OPERATION_FAILED: "ALDUS_RELEASE_REQUIRED_OPERATION_FAILED",
+    /**
+     * A stored receipt disagrees with the bundle that produced it.
+     *
+     * The identity of an operation is its `operationId` plus its idempotency key. A receipt whose
+     * key no longer matches describes a different operation than the one about to run, and reusing
+     * it would let changed inputs inherit an old approval's outcome.
+     */
+    RECEIPT_MISMATCH: "ALDUS_RELEASE_RECEIPT_MISMATCH",
+    /**
+     * Reconciliation was required but the adapter cannot look up remote state.
+     *
+     * Contract §17 requires operations to be resumable "where the platform allows it". Where it
+     * does not, the honest outcome is to say so rather than to re-execute and risk a duplicate
+     * publish.
+     */
+    RECONCILIATION_UNAVAILABLE: "ALDUS_RELEASE_RECONCILIATION_UNAVAILABLE",
+};
+/** Construct an {@link AldusError} with a release code. */
+export function releaseError(code, message, options) {
+    return new AldusError(code, message, options);
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAsB,MAAM,qBAAqB,CAAC;AAErE,kDAAkD;AAClD,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B;;;;;;;OAOG;IACH,sBAAsB,EAAE,8BAA8B;IACtD,+DAA+D;IAC/D,sBAAsB,EAAE,sCAAsC;IAC9D,oEAAoE;IACpE,mBAAmB,EAAE,mCAAmC;IACxD,0DAA0D;IAC1D,YAAY,EAAE,4BAA4B;IAC1C;;;;;;OAMG;IACH,yBAAyB,EAAE,yCAAyC;IACpE;;;;;;OAMG;IACH,gBAAgB,EAAE,gCAAgC;IAClD;;;;;;OAMG;IACH,0BAA0B,EAAE,0CAA0C;CAC9D,CAAC;AAKX,2DAA2D;AAC3D,MAAM,UAAU,YAAY,CAC1B,IAAsB,EACtB,OAAe,EACf,OAA4F;IAE5F,OAAO,IAAI,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC"}

package/dist/executor.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Release execution, resumption, and reconciliation (architecture contract §17, §19.1).
+ *
+ * Three properties drive the design, and each rules out the obvious implementation:
+ *
+ * 1. **§17: every operation is independently idempotent and resumable.** So execution is never a
+ *    transaction over a bundle. Each operation carries its own derived idempotency key and its
+ *    own receipt, and a half-executed bundle is resumed by skipping what already succeeded.
+ *
+ * 2. **§17: pre-release hard gates and post-upload best-effort operations are distinguished.**
+ *    The first failure among required operations stops the bundle — a failed media upload must
+ *    not be followed by a visibility transition making nothing public. A best-effort failure is
+ *    recorded and execution continues.
+ *
+ * 3. **§17: external state must be reconciled, not guessed.** A response lost after the
+ *    destination accepted a request leaves local records saying nothing happened while something
+ *    did. Retrying then publishes twice. So an operation whose outcome was recorded as `pending`
+ *    is never retried; it is looked up, and if the destination cannot be queried the executor
+ *    refuses rather than risking the duplicate.
+ *
+ * Nothing about a bundle's progress is stored beyond its receipts. State is derived on every
+ * call, for the reason ADR-0009 derives gate state: a stored progress flag survives a crash that
+ * the work it describes did not.
+ */
+import type { ActorRef, ReleaseReceipt } from "@aldus-runtime/core";
+import type { AdapterRegistry } from "./adapter.js";
+import { type ReleaseBundle } from "./bundle.js";
+import type { OperationCriticality } from "./operation.js";
+import { type ReleaseEventSink, type ReleaseReceiptStore } from "./ports.js";
+import { type ReleaseAuthorizer } from "./authorization.js";
+/** Where one operation stands. */
+export declare const OPERATION_STATES: readonly [
+/** No receipt exists; it has not been attempted. */
+"not_started", 
+/** Attempted, outcome unconfirmed. MUST be reconciled, never retried (contract §17). */
+"pending", 
+/** Completed at the destination. */
+"succeeded", 
+/** Attempted and rejected by the destination. */
+"failed", 
+/** Deliberately not attempted — no authority, or nothing to do. */
+"skipped"];
+/** @see OPERATION_STATES */
+export type OperationState = (typeof OPERATION_STATES)[number];
+/** The derived state of one operation in a bundle. */
+export interface OperationStatus {
+    operationId: string;
+    kind: string;
+    destination: string;
+    /** Which §17 category the bundle placed it in. */
+    criticality: OperationCriticality;
+    idempotencyKey: string;
+    state: OperationState;
+    /** The receipt this state was derived from, if any. */
+    receipt?: ReleaseReceipt;
+}
+/** Where a whole bundle stands (contract §19.1 "recovery from partial success"). */
+export interface BundleStatus {
+    bundleId: string;
+    runId: string;
+    /**
+     * `succeeded` once every required operation has succeeded, whatever became of the best-effort
+     * ones — that is what §17's distinction means in practice.
+     */
+    state: "not_started" | "in_progress" | "pending" | "failed" | "succeeded";
+    operations: OperationStatus[];
+    /** Operation ids that still need to run for the release to complete. */
+    remaining: string[];
+}
+/** What reconciliation did about one operation. */
+export interface ReconciliationFinding {
+    operationId: string;
+    idempotencyKey: string;
+    action: 
+    /** A terminal receipt already existed; nothing to do. */
+    "already_recorded"
+    /** The destination holds the result, so a missing or pending receipt was repaired. */
+     | "repaired"
+    /** The destination does not hold it, so the operation genuinely still needs to run. */
+     | "confirmed_absent"
+    /** The adapter cannot query the destination (contract §17 "where the platform allows it"). */
+     | "unavailable";
+    explanation?: string;
+}
+/** What a reconciliation pass found. */
+export interface ReconciliationReport {
+    bundleId: string;
+    runId: string;
+    findings: ReconciliationFinding[];
+    /** Receipts written to repair the local record. */
+    repaired: ReleaseReceipt[];
+}
+/** The result of executing a bundle. */
+export interface ReleaseOutcome {
+    bundleId: string;
+    runId: string;
+    /**
+     * `succeeded` when every required operation succeeded. A best-effort failure does not change
+     * it (contract §17).
+     */
+    state: "succeeded" | "failed" | "pending";
+    status: BundleStatus;
+    /** Receipts written by this call, in order. */
+    written: ReleaseReceipt[];
+    /** Operator-facing notes: best-effort failures, skipped operations, reconciliation actions. */
+    warnings: string[];
+}
+/**
+ * Options for one reconciliation.
+ *
+ * Reconciliation writes receipts, which makes it a mutating action, and §19.2 requires a
+ * mutating action to record actor identity. A repair attributed to no one is a record an
+ * operator cannot question later, so the actor is required rather than defaulted to a system
+ * placeholder.
+ */
+export interface ReconcileOptions {
+    /** Who is reconciling (contract §19.2). */
+    actor: ActorRef;
+}
+/** Options for one execution. */
+export interface ExecuteOptions {
+    /** Who is releasing (contract §19.2 "mutating actions MUST record actor identity"). */
+    actor: ActorRef;
+    /**
+     * Reconcile before executing. Default `true`.
+     *
+     * Turning it off is what a blind retry looks like, and it is the unsafe path — it exists so
+     * the tests can demonstrate the duplicate publish that reconciliation prevents.
+     */
+    reconcile?: boolean;
+}
+/** Wiring for a {@link ReleaseExecutor}. */
+export interface ReleaseExecutorOptions {
+    adapters: AdapterRegistry;
+    receipts: ReleaseReceiptStore;
+    events: ReleaseEventSink;
+    /** Defaults to permitting everything, which is only correct when no operation needs authority. */
+    authorizer?: ReleaseAuthorizer;
+    /** Injected for deterministic tests. */
+    now?: () => Date;
+    /** Injected for deterministic tests. */
+    nextReleaseId?: () => string;
+    /** Injected for deterministic tests. */
+    nextEventId?: () => string;
+}
+/** Executes release bundles, resumably. */
+export declare class ReleaseExecutor {
+    #private;
+    constructor(options: ReleaseExecutorOptions);
+    /**
+     * Derive where a bundle stands from its receipts (contract §19.1).
+     *
+     * Reads only; safe to call at any time, including on a bundle that has never run.
+     */
+    status(bundle: ReleaseBundle): Promise<BundleStatus>;
+    /**
+     * Repair the local record against the destinations (contract §17).
+     *
+     * Only operations without a terminal local receipt are looked up: an operation already
+     * recorded as succeeded or failed has an answer, and asking again would turn reconciliation
+     * into polling.
+     */
+    reconcile(bundle: ReleaseBundle, options: ReconcileOptions): Promise<ReconciliationReport>;
+    /**
+     * Execute a bundle, resuming whatever has already succeeded (contract §17, §19.1).
+     *
+     * Reconciles first by default, so the safe path is the one a caller gets without asking.
+     */
+    execute(bundle: ReleaseBundle, options: ExecuteOptions): Promise<ReleaseOutcome>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

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