@deftai/directive-core 0.55.0

package/dist/release/version.d.ts

@@ -0,0 +1,11 @@
+export declare class NonPublishableVersionError extends Error {
+    constructor(message: string);
+}
+/** Raise Error when version does not match strict X.Y.Z semver. */
+export declare function validateVersion(version: string): void;
+/** Return true when version carries a SemVer pre-release suffix (#425). */
+export declare function isPrereleaseTag(version: string): boolean;
+/** Normalize a semver-shaped release tag to a PEP 440 version string (#771). */
+export declare function toPep440(version: string): string;
+export declare function isPublishable(version: string): boolean;
+//# sourceMappingURL=version.d.ts.map

package/dist/release/version.js

@@ -0,0 +1,74 @@
+const PEP440_TAG_RE = /^v?(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<kind>rc|alpha|beta|test)\.(?<num>\d+))?$/;
+const PRE_KIND_MAP = {
+    alpha: "a",
+    beta: "b",
+    rc: "rc",
+};
+const NON_PUBLISHABLE_KINDS = new Set(["test"]);
+export class NonPublishableVersionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NonPublishableVersionError";
+    }
+}
+/** Raise Error when version does not match strict X.Y.Z semver. */
+export function validateVersion(version) {
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+        throw new Error(`Invalid version '${version}'. Expected strict semver X.Y.Z ` +
+            "(no leading 'v', no pre-release suffix).");
+    }
+}
+/** Return true when version carries a SemVer pre-release suffix (#425). */
+export function isPrereleaseTag(version) {
+    let candidate = version.trim();
+    if (candidate.startsWith("v")) {
+        candidate = candidate.slice(1);
+    }
+    return candidate.includes("-");
+}
+/** Normalize a semver-shaped release tag to a PEP 440 version string (#771). */
+export function toPep440(version) {
+    if (typeof version !== "string") {
+        throw new Error(`version must be a string, got ${typeof version}`);
+    }
+    const candidate = version.trim();
+    if (!candidate) {
+        throw new Error("version must be a non-empty string");
+    }
+    const match = PEP440_TAG_RE.exec(candidate);
+    if (match?.groups === undefined) {
+        throw new Error(`Cannot normalize '${candidate}' to PEP 440: expected ` +
+            "[v]X.Y.Z or [v]X.Y.Z-(rc|alpha|beta|test).N");
+    }
+    const major = Number(match.groups.major);
+    const minor = Number(match.groups.minor);
+    const patch = Number(match.groups.patch);
+    const base = `${major}.${minor}.${patch}`;
+    const kind = match.groups.kind;
+    if (kind === undefined) {
+        return base;
+    }
+    if (NON_PUBLISHABLE_KINDS.has(kind)) {
+        throw new NonPublishableVersionError(`Version '${candidate}' carries non-publishable pre-release ` +
+            `tag '${kind}'.${match.groups.num} -- release pipeline MUST ` +
+            "skip pyproject.toml [project].version sync for this tag.");
+    }
+    const pepKind = PRE_KIND_MAP[kind];
+    if (pepKind === undefined) {
+        throw new Error(`Unmapped pre-release kind '${kind}' for version '${candidate}'; ` +
+            "add it to _PRE_KIND_MAP or _NON_PUBLISHABLE_KINDS to keep " +
+            "_PEP440_TAG_RE in lockstep with the publishability classifier.");
+    }
+    const pepNum = Number(match.groups.num);
+    return `${base}${pepKind}${pepNum}`;
+}
+export function isPublishable(version) {
+    try {
+        toPep440(version);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=version.js.map

package/dist/release-e2e/constants.d.ts

@@ -0,0 +1,22 @@
+/** Exit codes mirroring scripts/release_e2e.py (via scripts/release.py). */
+export declare const EXIT_OK = 0;
+export declare const EXIT_VIOLATION = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export declare const DEFAULT_OWNER = "deftai";
+export declare const REPO_SLUG_PREFIX = "deftai-release-test-";
+/** Fixed sentinel rehearsal version (#720). */
+export declare const REHEARSAL_VERSION = "0.0.1";
+/**
+ * #1910: dependency order for the npm publish dry-run rehearsal, mirroring
+ * .github/workflows/npm-publish.yml (types -> core -> content -> cli).
+ */
+export declare const NPM_PUBLISH_PACKAGES: readonly ["types", "core", "content", "cli"];
+export declare const NPM_INSTALL_TIMEOUT_SECONDS = 600;
+export declare const NPM_BUILD_TIMEOUT_SECONDS = 600;
+export declare const NPM_PUBLISH_DRYRUN_TIMEOUT_SECONDS = 180;
+export declare const RELEASE_ENTRYPOINT_TIMEOUT_SECONDS = 600;
+export declare const ROLLBACK_ENTRYPOINT_TIMEOUT_SECONDS = 300;
+export declare const ENTRYPOINT_TIMEOUT_EXIT_CODE = 124;
+/** Byte-identical --help from scripts/release_e2e.py (Python 3.12 argparse). */
+export declare const RELEASE_E2E_HELP: string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/release-e2e/constants.js

@@ -0,0 +1,43 @@
+/** Exit codes mirroring scripts/release_e2e.py (via scripts/release.py). */
+export const EXIT_OK = 0;
+export const EXIT_VIOLATION = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const DEFAULT_OWNER = "deftai";
+export const REPO_SLUG_PREFIX = "deftai-release-test-";
+/** Fixed sentinel rehearsal version (#720). */
+export const REHEARSAL_VERSION = "0.0.1";
+/**
+ * #1910: dependency order for the npm publish dry-run rehearsal, mirroring
+ * .github/workflows/npm-publish.yml (types -> core -> content -> cli).
+ */
+export const NPM_PUBLISH_PACKAGES = ["types", "core", "content", "cli"];
+export const NPM_INSTALL_TIMEOUT_SECONDS = 600;
+export const NPM_BUILD_TIMEOUT_SECONDS = 600;
+export const NPM_PUBLISH_DRYRUN_TIMEOUT_SECONDS = 180;
+export const RELEASE_ENTRYPOINT_TIMEOUT_SECONDS = 600.0;
+export const ROLLBACK_ENTRYPOINT_TIMEOUT_SECONDS = 300.0;
+export const ENTRYPOINT_TIMEOUT_EXIT_CODE = 124;
+/** Byte-identical --help from scripts/release_e2e.py (Python 3.12 argparse). */
+export const RELEASE_E2E_HELP = "usage: release_e2e [-h] [--owner OWNER] [--dry-run] [--keep-repo]\n" +
+    "                   [--project-root PATH] [--skip-npm]\n" +
+    "\n" +
+    "End-to-end release rehearsal against an auto-created+destroyed temp GitHub\n" +
+    "repo (#716 safety hardening Q1).\n" +
+    "\n" +
+    "options:\n" +
+    "  -h, --help           show this help message and exit\n" +
+    "  --owner OWNER        GitHub owner under which to create the temp repo\n" +
+    "                       (default: deftai).\n" +
+    "  --dry-run            Print the pipeline plan without invoking gh.\n" +
+    "  --keep-repo          Skip destroying the temp repo at the end (use only when\n" +
+    "                       manually debugging a failed rehearsal; remember to\n" +
+    "                       clean up by hand).\n" +
+    "  --project-root PATH  Repository root (default: $DEFT_PROJECT_ROOT or\n" +
+    "                       scripts/.. ).\n" +
+    "  --skip-npm           Skip the npm publish dry-run rehearsal step (#1910).\n" +
+    "                       The step installs + builds the workspace, which exceeds\n" +
+    "                       the <90s fast budget that --skip-ci/--skip-build\n" +
+    "                       protect; use this to keep the rehearsal fast. The step\n" +
+    "                       also soft-skips on its own when npm is absent from\n" +
+    "                       PATH.\n";
+//# sourceMappingURL=constants.js.map

package/dist/release-e2e/entrypoint-worker-thread.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entrypoint-worker-thread.d.ts.map

package/dist/release-e2e/entrypoint-worker-thread.js

@@ -0,0 +1,22 @@
+/* v8 ignore start -- worker-thread bootstrap; exercised via runEntrypointWorker integration. */
+import { parentPort, workerData } from "node:worker_threads";
+import { runWorkerEntrypoint } from "./entrypoint-worker.js";
+const data = workerData;
+const result = runWorkerEntrypoint(data);
+const target = data.port ?? parentPort;
+try {
+    target?.postMessage(result);
+}
+catch {
+    // The parent may have closed the MessageChannel after a timeout +
+    // worker.terminate() (e.g. the slow "hang" path). Posting to a closed port
+    // throws here, outside runWorkerEntrypoint's catch -- which would surface as
+    // a worker 'error' event. The parent already returned its timeout result, so
+    // swallow it (#1864 / #1865 review).
+}
+if (data.signal !== undefined) {
+    Atomics.store(data.signal, 0, 1);
+    Atomics.notify(data.signal, 0);
+}
+/* v8 ignore stop */
+//# sourceMappingURL=entrypoint-worker-thread.js.map

package/dist/release-e2e/entrypoint-worker.d.ts

@@ -0,0 +1,13 @@
+export interface WorkerEntrypointData {
+    kind: "release" | "rollback" | "test";
+    argv: string[];
+    cloneDir: string;
+    testBehavior?: "ok" | "hang" | "throw";
+}
+export interface WorkerEntrypointResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function runWorkerEntrypoint(data: WorkerEntrypointData): WorkerEntrypointResult;
+//# sourceMappingURL=entrypoint-worker.d.ts.map

package/dist/release-e2e/entrypoint-worker.js

@@ -0,0 +1,50 @@
+import { cmdRelease } from "../release/main.js";
+import { rollbackMain } from "./rollback-bridge.js";
+export function runWorkerEntrypoint(data) {
+    process.env.DEFT_PROJECT_ROOT = data.cloneDir;
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const prevStdout = process.stdout.write.bind(process.stdout);
+    const prevStderr = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk) => {
+        stdoutChunks.push(String(chunk));
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        stderrChunks.push(String(chunk));
+        return true;
+    });
+    let code = 0;
+    let error;
+    try {
+        if (data.kind === "release") {
+            code = cmdRelease(data.argv);
+        }
+        else if (data.kind === "rollback") {
+            code = rollbackMain(data.argv);
+        }
+        else if (data.testBehavior === "hang") {
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5_000);
+            code = 0;
+        }
+        else if (data.testBehavior === "throw") {
+            throw new Error("boom");
+        }
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? `${exc.name}: ${exc.message}` : String(exc);
+        const captured = stderrChunks.join("");
+        error = captured ? `${captured}\n${message}` : message;
+        code = 1;
+    }
+    finally {
+        process.stdout.write = prevStdout;
+        process.stderr.write = prevStderr;
+    }
+    return {
+        code: error ? 1 : code || 0,
+        stdout: stdoutChunks.join(""),
+        stderr: error ?? stderrChunks.join(""),
+    };
+}
+//# sourceMappingURL=entrypoint-worker.js.map

package/dist/release-e2e/entrypoint.d.ts

@@ -0,0 +1,40 @@
+import type { E2ESeams, EntrypointFn } from "./types.js";
+/** @internal Test hook for restore-owner branch coverage. */
+export declare function restoreProcessStateForTest(restoreOwner: symbol, oldCwd: string, oldProjectRoot: string | undefined): void;
+/**
+ * Synchronous worker-backed entrypoint runner (#1864).
+ *
+ * The earlier `runPromiseSync` deadlocked: it blocked the main thread with
+ * `Atomics.wait` while waiting on a Promise whose only settle paths
+ * (`worker.on("message")`, `worker.on("error")`, the timeout `setTimeout`)
+ * were main-thread event-loop callbacks -- which a blocked event loop can
+ * never run, so the `Atomics.notify` microtask never fired and the wait
+ * (and the timeout) hung forever.
+ *
+ * The fix relies on a CROSS-THREAD wake: the worker writes its result to a
+ * transferred MessagePort and calls `Atomics.notify` from the worker thread,
+ * which wakes the main thread's `Atomics.wait` without needing the event
+ * loop. `Atomics.wait`'s own `timeoutMs` is the working timeout backstop
+ * (covering the rare worker-load-failure-before-notify case), and
+ * `receiveMessageOnPort` reads the queued result synchronously.
+ */
+export declare function runEntrypointWorkerSync(kind: "release" | "rollback" | "test", argv: string[], cloneDir: string, timeoutMs: number, testBehavior?: "ok" | "hang" | "throw"): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+/** @internal Exported for unit tests that mock worker-backed timeouts. */
+export declare function runEntrypointWorker(kind: "release" | "rollback" | "test", argv: string[], cloneDir: string, timeoutMs: number, testBehavior?: "hang" | "throw"): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/** Run a release entrypoint in-process with subprocess-style bounds. */
+export declare function callReleaseEntrypoint(entrypoint: EntrypointFn, argv: string[], cloneDir: string, timeout?: number): [number, string];
+/** Async variant with timeout support (used for hang / worker-backed entrypoints). */
+export declare function callReleaseEntrypointTimed(kind: "release" | "rollback" | "test", argv: string[], cloneDir: string, timeout: number, testBehavior?: "hang" | "throw"): Promise<[number, string]>;
+export declare function defaultReleaseEntrypoint(argv: string[]): number;
+export declare function defaultRollbackEntrypoint(argv: string[]): number;
+export declare function dispatchTaskRelease(cloneDir: string, version: string, repo: string, seams?: E2ESeams): [boolean, string];
+export declare function dispatchTaskReleaseRollback(cloneDir: string, version: string, repo: string, seams?: E2ESeams): [boolean, string];
+//# sourceMappingURL=entrypoint.d.ts.map

package/dist/release-e2e/entrypoint.js

@@ -0,0 +1,257 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MessageChannel, receiveMessageOnPort, Worker } from "node:worker_threads";
+import { cmdRelease } from "../release/main.js";
+import { ENTRYPOINT_TIMEOUT_EXIT_CODE, EXIT_VIOLATION, RELEASE_ENTRYPOINT_TIMEOUT_SECONDS, ROLLBACK_ENTRYPOINT_TIMEOUT_SECONDS, } from "./constants.js";
+import { rollbackMain } from "./rollback-bridge.js";
+let activeRestoreOwner = null;
+/** @internal Test hook for restore-owner branch coverage. */
+export function restoreProcessStateForTest(restoreOwner, oldCwd, oldProjectRoot) {
+    restoreProcessState(restoreOwner, oldCwd, oldProjectRoot);
+}
+function restoreProcessState(restoreOwner, oldCwd, oldProjectRoot) {
+    if (activeRestoreOwner !== restoreOwner) {
+        return;
+    }
+    activeRestoreOwner = null;
+    process.chdir(oldCwd);
+    if (oldProjectRoot === undefined) {
+        delete process.env.DEFT_PROJECT_ROOT;
+    }
+    else {
+        process.env.DEFT_PROJECT_ROOT = oldProjectRoot;
+    }
+}
+function activateProcessState(restoreOwner, cloneDir) {
+    activeRestoreOwner = restoreOwner;
+    process.env.DEFT_PROJECT_ROOT = cloneDir;
+    mkdirSync(cloneDir, { recursive: true });
+    process.chdir(cloneDir);
+    return true;
+}
+function runEntrypointWithCapture(entrypoint, argv) {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const prevStdout = process.stdout.write.bind(process.stdout);
+    const prevStderr = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk) => {
+        stdoutChunks.push(String(chunk));
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        stderrChunks.push(String(chunk));
+        return true;
+    });
+    try {
+        const code = entrypoint(argv);
+        const output = stderrChunks.join("") || stdoutChunks.join("");
+        return [code || 0, output];
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? `${exc.name}: ${exc.message}` : String(exc);
+        const captured = stderrChunks.join("");
+        const stderrValue = captured ? `${captured}\n${message}` : message;
+        return [EXIT_VIOLATION, stderrValue || stdoutChunks.join("")];
+    }
+    finally {
+        process.stdout.write = prevStdout;
+        process.stderr.write = prevStderr;
+    }
+}
+/**
+ * Resolve the compiled worker-thread bootstrap path, preferring the sibling
+ * file when running from source and falling back to the dist mirror.
+ */
+function resolveWorkerPath() {
+    const localWorker = fileURLToPath(new URL("./entrypoint-worker-thread.js", import.meta.url));
+    const srcSegment = `${sep}src${sep}`;
+    const srcIdx = localWorker.indexOf(srcSegment);
+    const distWorker = srcIdx === -1
+        ? localWorker
+        : `${localWorker.slice(0, srcIdx)}${sep}dist${sep}${localWorker.slice(srcIdx + srcSegment.length)}`;
+    return existsSync(localWorker) ? localWorker : distWorker;
+}
+/**
+ * Synchronous worker-backed entrypoint runner (#1864).
+ *
+ * The earlier `runPromiseSync` deadlocked: it blocked the main thread with
+ * `Atomics.wait` while waiting on a Promise whose only settle paths
+ * (`worker.on("message")`, `worker.on("error")`, the timeout `setTimeout`)
+ * were main-thread event-loop callbacks -- which a blocked event loop can
+ * never run, so the `Atomics.notify` microtask never fired and the wait
+ * (and the timeout) hung forever.
+ *
+ * The fix relies on a CROSS-THREAD wake: the worker writes its result to a
+ * transferred MessagePort and calls `Atomics.notify` from the worker thread,
+ * which wakes the main thread's `Atomics.wait` without needing the event
+ * loop. `Atomics.wait`'s own `timeoutMs` is the working timeout backstop
+ * (covering the rare worker-load-failure-before-notify case), and
+ * `receiveMessageOnPort` reads the queued result synchronously.
+ */
+export function runEntrypointWorkerSync(kind, argv, cloneDir, timeoutMs, testBehavior) {
+    const workerPath = resolveWorkerPath();
+    const signal = new Int32Array(new SharedArrayBuffer(4)); // 0 = pending, 1 = settled
+    const channel = new MessageChannel();
+    let worker;
+    try {
+        worker = new Worker(workerPath, {
+            workerData: { kind, argv, cloneDir, signal, port: channel.port2, testBehavior },
+            transferList: [channel.port2],
+        });
+    }
+    catch (err) {
+        return {
+            code: EXIT_VIOLATION,
+            stdout: "",
+            stderr: err instanceof Error ? err.message : String(err),
+        };
+    }
+    // Crash guard: a worker 'error' event (async module-load failure, or a
+    // post-timeout throw when the worker posts to the already-closed port) is
+    // re-thrown as an uncaught exception if no listener is attached. We can't act
+    // on it here -- this function runs synchronously while the event loop is
+    // blocked in Atomics.wait, so an 'error' event can only be delivered on a
+    // later tick after we've already returned -- but registering a no-op listener
+    // keeps a late worker failure from crashing the whole process (#1864 / #1865).
+    worker.on("error", () => { });
+    try {
+        const waitResult = Atomics.wait(signal, 0, 0, timeoutMs);
+        if (waitResult === "timed-out") {
+            return {
+                code: ENTRYPOINT_TIMEOUT_EXIT_CODE,
+                stdout: "",
+                stderr: `${kind} timed out after ${timeoutMs / 1000}s`,
+            };
+        }
+        const received = receiveMessageOnPort(channel.port1);
+        if (received === undefined) {
+            return { code: EXIT_VIOLATION, stdout: "", stderr: "worker produced no result" };
+        }
+        return received.message;
+    }
+    finally {
+        channel.port1.close();
+        void worker.terminate();
+    }
+}
+/** @internal Exported for unit tests that mock worker-backed timeouts. */
+export async function runEntrypointWorker(kind, argv, cloneDir, timeoutMs, testBehavior) {
+    const workerPath = resolveWorkerPath();
+    return new Promise((resolvePromise) => {
+        let worker;
+        try {
+            worker = new Worker(workerPath, {
+                workerData: { kind, argv, cloneDir, testBehavior },
+            });
+        }
+        catch (err) {
+            resolvePromise({
+                code: EXIT_VIOLATION,
+                stdout: "",
+                stderr: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        let settled = false;
+        const finish = (payload) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            void worker.terminate();
+            resolvePromise(payload);
+        };
+        const timer = setTimeout(() => {
+            finish({
+                code: ENTRYPOINT_TIMEOUT_EXIT_CODE,
+                stdout: "",
+                stderr: `${kind} timed out after ${timeoutMs / 1000}s`,
+            });
+        }, timeoutMs);
+        worker.on("message", (msg) => finish(msg));
+        worker.on("error", (err) => finish({
+            code: EXIT_VIOLATION,
+            stdout: "",
+            stderr: err instanceof Error ? err.message : "worker error",
+        }));
+    });
+}
+function callReleaseEntrypointWorkerBacked(kind, argv, cloneDir, timeout) {
+    const timeoutMs = Math.max(1, Math.floor(timeout * 1000));
+    const result = runEntrypointWorkerSync(kind, argv, cloneDir, timeoutMs);
+    return [result.code, result.stderr || result.stdout];
+}
+/** Run a release entrypoint in-process with subprocess-style bounds. */
+export function callReleaseEntrypoint(entrypoint, argv, cloneDir, timeout = RELEASE_ENTRYPOINT_TIMEOUT_SECONDS) {
+    if (entrypoint === defaultReleaseEntrypoint) {
+        return callReleaseEntrypointWorkerBacked("release", argv, cloneDir, timeout);
+    }
+    if (entrypoint === defaultRollbackEntrypoint) {
+        return callReleaseEntrypointWorkerBacked("rollback", argv, cloneDir, timeout);
+    }
+    const oldCwd = process.cwd();
+    const oldProjectRoot = process.env.DEFT_PROJECT_ROOT;
+    const restoreOwner = Symbol("entrypoint-restore");
+    try {
+        activateProcessState(restoreOwner, cloneDir);
+        return runEntrypointWithCapture(entrypoint, argv);
+    }
+    finally {
+        restoreProcessState(restoreOwner, oldCwd, oldProjectRoot);
+    }
+}
+/** Async variant with timeout support (used for hang / worker-backed entrypoints). */
+export async function callReleaseEntrypointTimed(kind, argv, cloneDir, timeout, testBehavior) {
+    const oldCwd = process.cwd();
+    const oldProjectRoot = process.env.DEFT_PROJECT_ROOT;
+    const restoreOwner = Symbol("entrypoint-restore");
+    try {
+        activateProcessState(restoreOwner, cloneDir);
+        const timeoutMs = Math.max(1, Math.floor(timeout * 1000));
+        const result = await runEntrypointWorker(kind, argv, cloneDir, timeoutMs, testBehavior);
+        return [result.code, result.stderr || result.stdout];
+    }
+    finally {
+        restoreProcessState(restoreOwner, oldCwd, oldProjectRoot);
+    }
+}
+export function defaultReleaseEntrypoint(argv) {
+    return cmdRelease(argv);
+}
+export function defaultRollbackEntrypoint(argv) {
+    return rollbackMain(argv);
+}
+export function dispatchTaskRelease(cloneDir, version, repo, seams = {}) {
+    const argv = [version, "--repo", repo, "--skip-ci", "--skip-build", "--allow-vbrief-drift"];
+    if (seams.releaseEntrypoint) {
+        const code = seams.releaseEntrypoint(argv);
+        if (code !== 0) {
+            return [false, `release.py failed (exit ${code}): `];
+        }
+        return [true, `release.py ${version} --repo ${repo} (draft) ran clean`];
+    }
+    const entrypoint = defaultReleaseEntrypoint;
+    const [code, output] = callReleaseEntrypoint(entrypoint, argv, cloneDir, RELEASE_ENTRYPOINT_TIMEOUT_SECONDS);
+    if (code !== 0) {
+        return [false, `release.py failed (exit ${code}): ${output.trim()}`];
+    }
+    return [true, `release.py ${version} --repo ${repo} (draft) ran clean`];
+}
+export function dispatchTaskReleaseRollback(cloneDir, version, repo, seams = {}) {
+    const argv = [version, "--repo", repo];
+    if (seams.rollbackEntrypoint) {
+        const code = seams.rollbackEntrypoint(argv);
+        if (code !== 0) {
+            return [false, `release_rollback.py failed (exit ${code}): `];
+        }
+        return [true, `release_rollback.py ${version} --repo ${repo} ran clean`];
+    }
+    const entrypoint = defaultRollbackEntrypoint;
+    const [code, output] = callReleaseEntrypoint(entrypoint, argv, cloneDir, ROLLBACK_ENTRYPOINT_TIMEOUT_SECONDS);
+    if (code !== 0) {
+        return [false, `release_rollback.py failed (exit ${code}): ${output.trim()}`];
+    }
+    return [true, `release_rollback.py ${version} --repo ${repo} ran clean`];
+}
+//# sourceMappingURL=entrypoint.js.map

package/dist/release-e2e/flags.d.ts

@@ -0,0 +1,5 @@
+import type { E2ESeams } from "./types.js";
+export declare function emit(label: string, status: string): void;
+export declare function generateRepoSlug(seams?: E2ESeams): string;
+export declare function parseE2EFlags(argv: readonly string[]): import("./types.js").ParsedE2EFlags;
+//# sourceMappingURL=flags.d.ts.map

package/dist/release-e2e/flags.js

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+import { REPO_SLUG_PREFIX } from "./constants.js";
+export function emit(label, status) {
+    process.stderr.write(`[e2e] ${label}... ${status}\n`);
+}
+export function generateRepoSlug(seams = {}) {
+    if (seams.generateRepoSlug) {
+        return seams.generateRepoSlug();
+    }
+    const now = seams.now ?? (() => new Date());
+    const d = now();
+    const timestamp = String(d.getUTCFullYear()) +
+        String(d.getUTCMonth() + 1).padStart(2, "0") +
+        String(d.getUTCDate()).padStart(2, "0") +
+        String(d.getUTCHours()).padStart(2, "0") +
+        String(d.getUTCMinutes()).padStart(2, "0") +
+        String(d.getUTCSeconds()).padStart(2, "0");
+    const suffix = (seams.randomUuidHex ?? (() => randomUUID().replace(/-/g, "")))().slice(0, 6);
+    return `${REPO_SLUG_PREFIX}${timestamp}-${suffix}`;
+}
+export function parseE2EFlags(argv) {
+    let help = false;
+    let owner = "deftai";
+    let dryRun = false;
+    let keepRepo = false;
+    let projectRoot = null;
+    let skipNpm = false;
+    const unknown = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "-h" || arg === "--help") {
+            help = true;
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--keep-repo") {
+            keepRepo = true;
+        }
+        else if (arg === "--skip-npm") {
+            skipNpm = true;
+        }
+        else if (arg === "--owner") {
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                unknown.push(arg);
+            }
+            else {
+                owner = next;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--owner=")) {
+            owner = arg.slice("--owner=".length);
+        }
+        else if (arg === "--project-root") {
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                unknown.push(arg);
+            }
+            else {
+                projectRoot = next;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg.startsWith("-")) {
+            unknown.push(arg);
+        }
+        else {
+            unknown.push(arg);
+        }
+    }
+    return { help, owner, dryRun, keepRepo, projectRoot, skipNpm, unknown };
+}
+//# sourceMappingURL=flags.js.map

package/dist/release-e2e/gh-ops.d.ts

@@ -0,0 +1,5 @@
+import type { E2ESeams } from "./types.js";
+export declare function provisionTempRepo(owner: string, slug: string, seams?: E2ESeams): [boolean, string];
+export declare function destroyTempRepo(owner: string, slug: string, seams?: E2ESeams): [boolean, string];
+export declare function verifyDraftRelease(owner: string, slug: string, version: string, seams?: E2ESeams): [boolean, string];
+//# sourceMappingURL=gh-ops.d.ts.map