@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/amend.js

@@ -1,236 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-import { isTerminalState } from "./status/lifecycle.js";
-import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
-import { resolveDefaultBranch } from "./status/drift.js";
-import { markdownSourceSections, normalizeScopePattern, ScopePatternError, validateScopeFragmentLines } from "./scope.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-import { isCompleteLifecycleOutcome } from "./outcome-base.js";
-import { getConfig } from "../config/env.js";
-function amendScopeHeading(name) {
-    return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
-}
-function parseAmendScopeSections(markdown) {
-    const sections = {};
-    for (const section of markdownSourceSections(markdown)) {
-        if (section.level !== 2)
-            continue;
-        const title = normalizeSectionTitle(section.title);
-        if (title === "scope add") {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", "Scope Add is obsolete; use ## Scope Append with a fenced gitignore-subset block");
-        }
-        if (title !== "scope append")
-            continue;
-        if (sections.append) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading("append")} at most once`);
-        }
-        sections.append = {
-            name: "append",
-            start: section.start,
-            contentStart: section.contentStart,
-            end: section.end,
-        };
-    }
-    let prose = markdown;
-    for (const section of Object.values(sections).sort((left, right) => right.start - left.start)) {
-        prose = `${prose.slice(0, section.start)}${prose.slice(section.end)}`;
-    }
-    return { sections, prose };
-}
-function scopePatterns(markdown, section) {
-    return validateScopeFragmentLines(markdown.slice(section.contentStart, section.end).split(/\r?\n/), {
-        heading: amendScopeHeading(section.name),
-        emptyMessage: `amend input has an empty ${amendScopeHeading(section.name)} section`,
-    });
-}
-function normalizeAmendScopePatterns(patterns) {
-    try {
-        return patterns.map((pattern) => normalizeScopePattern(pattern));
-    }
-    catch (error) {
-        if (error instanceof ScopePatternError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
-        }
-        throw error;
-    }
-}
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource, appendScope) {
-    const { sections, prose } = parseAmendScopeSections(markdown);
-    if (sections.append && appendScope && appendScope.length > 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may use either --append-scope or ## Scope Append, not both");
-    }
-    const append = sections.append
-        ? scopePatterns(markdown, sections.append)
-        : normalizeAmendScopePatterns(appendScope ?? []);
-    if (!prose.trim()) {
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    }
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        amendment: prose,
-        ...(append.length > 0 ? { scopeDelta: { add: append } } : {}),
-    };
-}
-function requireAmendment(value) {
-    if (!value.trim())
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    return value;
-}
-function assertContractOperable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (isTerminalState(state)) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is terminal (${state.state})`);
-    }
-}
-function normalizeScopeDelta(scopeDelta) {
-    if (!scopeDelta)
-        return undefined;
-    // Scope patterns are gitignore text; do not requireText/trim, or escaped trailing spaces die.
-    const add = normalizeAmendScopePatterns(scopeDelta.add);
-    if (add.length === 0)
-        return undefined;
-    return { add };
-}
-export async function amendContract(input) {
-    const amendment = requireAmendment(input.amendment);
-    const scopeDelta = normalizeScopeDelta(input.scopeDelta);
-    const at = new Date(input.nowMs).toISOString();
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "amend",
-            // Amendment content is not a retry key; the containing Lnew is the sole mutation identity.
-            matchesAccepted: () => false,
-        },
-        signal: input.signal,
-        admit: (session, replay) => {
-            assertContractOperable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available")
-                throw new FlowError("INTERNAL_STATE", session.target.reason);
-            const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
-            const accepted = transaction?.entries.at(-1);
-            if (accepted && accepted.kind !== "amend")
-                throw new FlowError("INTERNAL_STATE", `accepted transaction ${transaction.transactionObjectId} is not an amend`);
-            const existing = accepted?.kind === "amend" ? { transactionObjectId: transaction.transactionObjectId } : undefined;
-            const amendmentCount = session.lifecycle.history.filter(({ entry }) => entry.kind === "amend").length;
-            return {
-                amendmentNumber: amendmentCount + (existing ? 0 : 1),
-                targetRoot: session.target.root,
-                ...(existing ? { existing } : {}),
-            };
-        },
-        prepare: (admission) => {
-            if (admission.business.existing) {
-                return {
-                    amendmentNumber: admission.business.amendmentNumber,
-                    existing: admission.business.existing,
-                    entry: null,
-                };
-            }
-            return {
-                amendmentNumber: admission.business.amendmentNumber,
-                entry: {
-                    v: 1,
-                    kind: "amend",
-                    contract: input.contractId,
-                    at,
-                    actor: input.actor,
-                    data: { amendment, ...(scopeDelta ? { scopeDelta } : {}) },
-                },
-            };
-        },
-        revalidate: ({ session, admission, prepared }) => {
-            assertContractOperable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available") {
-                return { code: "CARRIER_TARGET_UNAVAILABLE", message: session.target.reason };
-            }
-            if (prepared.existing) {
-                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
-                    ? undefined
-                    : { code: "AMEND_STATE_CHANGED", message: "accepted amend changed during replay preparation" };
-            }
-            const amendmentNumber = session.lifecycle.history.filter(({ entry }) => entry.kind === "amend").length + 1;
-            return amendmentNumber === admission.business.amendmentNumber
-                ? undefined
-                : { code: "AMENDMENT_NUMBER_CHANGED", message: "amendment sequence changed during preparation" };
-        },
-        effect: async ({ context, admission, prepared }) => {
-            const result = prepared.existing
-                ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
-                : await context.publishAuthoritative({ verb: "amend", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [prepared.entry] });
-            if (result.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
-            }
-            if (result.status !== "committed") {
-                return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during amend` } };
-            }
-            return {
-                kind: "committed",
-                commit: result,
-                entryKind: "amend",
-                value: {
-                    amendmentNumber: prepared.amendmentNumber,
-                    amendmentWarning: input.amendmentWarningThreshold === undefined
-                        ? undefined
-                        : prepared.amendmentNumber > input.amendmentWarningThreshold
-                            ? { amendmentCount: prepared.amendmentNumber, threshold: input.amendmentWarningThreshold }
-                            : undefined,
-                    targetRoot: admission.business.targetRoot,
-                },
-            };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return {
-        ...execution.outcome,
-        contractId: input.contractId,
-        amendmentNumber: execution.payload.amendmentNumber,
-        ...(execution.payload.amendmentWarning ? { amendmentWarning: execution.payload.amendmentWarning } : {}),
-        ledgerHead: execution.outcome.committed.head,
-        carrier: execution.carrier,
-        targetRoot: execution.payload.targetRoot,
-    };
-}
-export async function amendKeiyaku(input) {
-    await requireGitRepository(input.cwd, "amend");
-    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
-    return await withResolvedAddress(address, async () => {
-        const contractId = address.binding.commissionId;
-        const amendment = requireAmendment(input.amendment);
-        const amendmentWarningThreshold = getConfig().amendmentWarning.threshold;
-        const amended = await amendContract({
-            cwd: input.cwd,
-            contractId,
-            actor: "keiyaku",
-            nowMs: Date.now(),
-            amendment,
-            amendmentWarningThreshold,
-            scopeDelta: input.scopeDelta,
-            signal: input.signal,
-        });
-        if (!isCompleteLifecycleOutcome(amended))
-            return amended;
-        const { targetRoot, ...amendedFacts } = amended;
-        const currentBranch = await getCurrentBranch(targetRoot);
-        const baseBranch = (await resolveDefaultBranch(input.cwd))?.branch ?? currentBranch;
-        return {
-            ...amendedFacts,
-            status: "success",
-            amendmentNumber: amended.amendmentNumber,
-            currentBranch,
-            baseBranch,
-            ledgerCommit: amended.ledgerHead,
-            summary: `Appended Amendment ${amended.amendmentNumber} to contract ledger ${contractId}.`,
-            address,
-            carrier: amended.carrier,
-        };
-    });
-}

package/build/core/amendment-criteria.js

@@ -1,17 +0,0 @@
-import { parseToAST } from "./markdown/parser.js";
-import { extractListItems } from "./markdown/render.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-/** Criteria declared by one lawful amendment, without imposing bind-document grammar. */
-export function amendmentCriteria(amendment) {
-    const criteria = [];
-    for (const node of parseToAST(amendment).children) {
-        if (node.type !== "section" || node.level !== 2 || normalizeSectionTitle(node.title) !== "criteria")
-            continue;
-        criteria.push(...extractListItems(node).map((item) => item.trim()).filter(Boolean));
-    }
-    return criteria;
-}
-/** Bind declarations first, then amendment declarations in accepted lifecycle order. */
-export function effectiveCriteria(bindCriteria, amendments) {
-    return [...bindCriteria, ...amendments.flatMap(amendmentCriteria)];
-}

package/build/core/amendment-warning.js

@@ -1,10 +0,0 @@
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-export function deriveAmendmentWarning(model, threshold) {
-    if (model.history[0]?.entry.kind !== "bind")
-        return undefined;
-    const state = currentLifecycleState(model);
-    if (state.state === "claimed" || state.state === "forfeited")
-        return undefined;
-    const amendmentCount = model.history.filter(({ entry }) => entry.kind === "amend").length;
-    return amendmentCount > threshold ? { amendmentCount, threshold } : undefined;
-}

package/build/core/arc.js

@@ -1,293 +0,0 @@
-import { requireText, FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
-import { ACTOR_IDENTITY } from "../keiyaku.js";
-import { normalizeInlineTitle } from "./markdown/titles.js";
-import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle, } from "./command-markdown.js";
-import { isCompleteLifecycleOutcome } from "./outcome-base.js";
-import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { captureFoldedSeal, findOpenArc } from "./seal.js";
-import { normalizeScopePattern } from "./scope.js";
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-import { isTerminalState } from "./status/lifecycle.js";
-import { resolveDefaultBranch } from "./status/drift.js";
-import { persistResponseHistory } from "./transcripts.js";
-export function buildArcViews(entries) {
-    const arcs = new Map();
-    for (const entry of entries) {
-        if (entry.kind === "arc") {
-            arcs.set(entry.data.arc, {
-                arc: entry.data.arc,
-                title: entry.data.title,
-                objective: entry.data.objective,
-                brief: entry.data.brief,
-                open: entry,
-            });
-        }
-        if (entry.kind === "seal") {
-            const arc = arcs.get(entry.data.arc);
-            if (arc)
-                arc.seal = entry;
-        }
-    }
-    return [...arcs.values()].sort((left, right) => left.arc - right.arc);
-}
-export function findOpenArcView(entries) {
-    const open = findOpenArc(entries);
-    if (!open)
-        return null;
-    return buildArcViews(entries).find((arc) => arc.arc === open.data.arc) ?? null;
-}
-function assertArcOpenable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (state.state === "bound" || state.state === "active")
-        return;
-    if (isTerminalState(state) || state.state === "petitioned") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot open arc from state ${state.state}`);
-    }
-}
-export async function openArc(input) {
-    const title = requireText("title", input.title);
-    const objective = requireText("objective", input.objective);
-    const brief = requireText("brief", input.brief);
-    const patterns = input.appendScope?.map(normalizeScopePattern) ?? [];
-    const at = new Date(input.nowMs).toISOString();
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "arc",
-            matchesAccepted: (transaction) => {
-                const accepted = transaction.entries.at(-1);
-                const acceptedAmend = transaction.entries.find((entry) => entry.kind === "amend");
-                const acceptedPatterns = acceptedAmend?.kind === "amend" ? acceptedAmend.data.scopeDelta?.add ?? [] : [];
-                return accepted?.kind === "arc"
-                    && accepted.data.title === title
-                    && accepted.data.objective === objective
-                    && accepted.data.brief === brief
-                    && JSON.stringify(acceptedPatterns) === JSON.stringify(patterns);
-            },
-        },
-        signal: input.signal,
-        admit: (session, replay) => {
-            assertArcOpenable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available")
-                throw new FlowError("INTERNAL_STATE", session.target.reason);
-            const accepted = replay.state === "verb-committed" ? replay.transaction.entries.at(-1) : undefined;
-            let existing;
-            if (accepted?.kind === "arc" && replay.state === "verb-committed") {
-                const seal = replay.transaction.entries.find((entry) => entry.kind === "seal");
-                existing = {
-                    transactionObjectId: replay.transaction.transactionObjectId,
-                    arcNumber: accepted.data.arc,
-                    capture: seal?.kind === "seal" ? {
-                        arc: seal.data.arc,
-                        oldFence: seal.data.oldFence,
-                        newFence: seal.data.newFence,
-                        receipts: [...seal.data.receipts],
-                        diffstat: { ...seal.data.diffstat },
-                        scopeAudit: { violations: [...seal.data.scopeAudit.violations] },
-                        scopeViolationEvidence: [],
-                    } : null,
-                };
-            }
-            return { lifecycle: session.lifecycle, targetRoot: session.target.root, ...(existing ? { existing } : {}) };
-        },
-        prepare: async (admission) => {
-            if (admission.business.existing) {
-                return {
-                    additions: [],
-                    arcNumber: admission.business.existing.arcNumber,
-                    capture: admission.business.existing.capture,
-                    existing: admission.business.existing,
-                };
-            }
-            const scopeEntry = patterns.length === 0 ? null : {
-                v: 1,
-                kind: "amend",
-                contract: input.contractId,
-                at,
-                actor: input.actor,
-                data: { amendment: "Scope extended by lifecycle command.", scopeDelta: { add: patterns } },
-            };
-            const capture = await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD", patterns);
-            const arcNumber = admission.business.lifecycle.intent.arc + 1;
-            let sealEntry = null;
-            if (capture) {
-                const { scopeViolationEvidence: _evidence, ...durableCapture } = capture;
-                sealEntry = {
-                    v: 2,
-                    kind: "seal",
-                    contract: input.contractId,
-                    at,
-                    actor: "engine",
-                    data: { ...durableCapture, sealedBy: "arc" },
-                };
-            }
-            const arcEntry = {
-                v: 1,
-                kind: "arc",
-                contract: input.contractId,
-                at,
-                actor: input.actor,
-                data: { arc: arcNumber, title, objective, brief },
-            };
-            const additions = scopeEntry
-                ? sealEntry ? [scopeEntry, sealEntry, arcEntry] : [scopeEntry, arcEntry]
-                : sealEntry ? [sealEntry, arcEntry] : [arcEntry];
-            return { additions, arcNumber, capture };
-        },
-        revalidate: async ({ session, prepared }) => {
-            assertArcOpenable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available")
-                return { code: "CARRIER_TARGET_UNAVAILABLE", message: session.target.reason };
-            if (prepared.existing) {
-                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
-                    ? undefined
-                    : { code: "ARC_STATE_CHANGED", message: "accepted arc changed during replay preparation" };
-            }
-            await assertCleanTrackedWorkingTree(session.target.root);
-            return session.lifecycle.intent.arc + 1 === prepared.arcNumber
-                ? undefined
-                : { code: "ARC_NUMBER_CHANGED", message: "arc sequence changed during preparation" };
-        },
-        effect: async ({ context, admission, prepared }) => {
-            const result = prepared.existing
-                ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
-                : await context.publishAuthoritative({
-                    verb: "arc",
-                    admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
-                    entries: prepared.additions,
-                });
-            if (result.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
-            }
-            if (result.status !== "committed" || prepared.arcNumber === 0) {
-                return { kind: "refused-before-effects", authoritativeHead: result.status === "committed" ? result.head : result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during arc` } };
-            }
-            const committedCapture = prepared.capture;
-            const sealed = committedCapture && {
-                ...committedCapture,
-                sealedBy: "arc",
-                ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")],
-            };
-            let response;
-            if (input.persistResponse) {
-                await context.journal.run({
-                    effect: "response-history-persistence",
-                    run: async () => {
-                        response = await input.persistResponse({ ledgerHead: result.head, sealed });
-                        return response;
-                    },
-                });
-            }
-            return {
-                kind: "committed",
-                commit: result,
-                entryKind: "arc",
-                value: {
-                    arc: prepared.arcNumber,
-                    sealed,
-                    targetRoot: admission.business.targetRoot,
-                    ...(response ?? {}),
-                },
-            };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return {
-        ...execution.outcome,
-        contractId: input.contractId,
-        arc: execution.payload.arc,
-        ledgerHead: execution.outcome.committed.head,
-        sealed: execution.payload.sealed,
-        carrier: execution.carrier,
-        targetRoot: execution.payload.targetRoot,
-        ...(execution.payload.responsePath ? { responsePath: execution.payload.responsePath } : {}),
-        ...(execution.payload.artifactId ? { artifactId: execution.payload.artifactId } : {}),
-    };
-}
-export function buildArcInput(content, cwd, appendScope = [], contractId, contractAddressSource) {
-    const parts = parseCommandMarkdown(content);
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        title: requireMarkdownTitle(parts),
-        objective: requireMarkdownTextSection(parts, "Objective"),
-        brief: requireMarkdownTextSection(parts, "Brief"),
-        appendScope,
-    };
-}
-async function readBranchLabels(cwd) {
-    const currentBranch = await getCurrentBranch(cwd);
-    const baseBranch = (await resolveDefaultBranch(cwd))?.branch ?? currentBranch;
-    return { currentBranch, baseBranch };
-}
-export async function arcKeiyaku(input) {
-    await requireGitRepository(input.cwd, "arc");
-    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
-    return await withResolvedAddress(address, async () => {
-        const contractId = address.binding.commissionId;
-        const title = normalizeInlineTitle(requireText("title", input.title));
-        const objective = requireText("objective", input.objective);
-        const brief = requireText("brief", input.brief);
-        const nowMs = Date.now();
-        const summaryFor = (sealed, arc) => sealed
-            ? `a${sealed.arc} sealed; a${arc} open: ${title}.`
-            : `a${arc} open: ${title}.`;
-        const opened = await openArc({
-            cwd: input.cwd,
-            contractId,
-            actor: ACTOR_IDENTITY,
-            nowMs,
-            title,
-            objective,
-            brief,
-            appendScope: input.appendScope,
-            signal: input.signal,
-            persistResponse: async ({ ledgerHead, sealed }) => persistResponseHistory({
-                cwd: input.cwd,
-                tool: "arc",
-                provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: input.cwd },
-                title,
-                objective,
-                brief,
-                ledgerCommit: ledgerHead,
-                summary: summaryFor(sealed, (sealed?.arc ?? 0) + 1),
-                emptyDiffLabel: "working tree untouched",
-                ...(sealed ? { sealed } : {}),
-            }),
-        });
-        if (!isCompleteLifecycleOutcome(opened))
-            return opened;
-        const { targetRoot, ...openedFacts } = opened;
-        const { currentBranch, baseBranch } = await readBranchLabels(targetRoot);
-        const summary = summaryFor(opened.sealed, opened.arc);
-        return {
-            ...openedFacts,
-            status: "success",
-            arc: opened.arc,
-            currentBranch,
-            baseBranch,
-            commit: opened.ledgerHead,
-            // CLI/render synthesizes public face bytes from sealed typed facts.
-            diff: "",
-            summary,
-            title,
-            objective,
-            brief,
-            ledgerCommit: opened.ledgerHead,
-            sealed: opened.sealed ?? undefined,
-            responsePath: opened.responsePath,
-            artifactId: opened.artifactId,
-            address,
-            carrier: opened.carrier,
-        };
-    });
-}

package/build/core/atomic-publish.js

@@ -1,64 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../errno.js";
-export class ProjectionStateError extends Error {
-    code = "PROJECTION_STATE_ERROR";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionStateError";
-    }
-}
-export function randomHex8() {
-    return crypto.randomBytes(4).toString("hex");
-}
-/**
- * Atomic publish: O_EXCL temp write → linkSync temp→target → unlink temp.
- * link EEXIST returns 'taken' (no retry). Temp EEXIST retries up to maxTempRetries.
- * No startup .tmp.* GC; orphan temps are left behind on unlink failure.
- */
-export function atomicPublishFile(target, content, maxTempRetries = 3, options) {
-    if (!Number.isInteger(maxTempRetries) || maxTempRetries < 1) {
-        throw new ProjectionStateError("maxTempRetries must be a positive integer");
-    }
-    const directory = path.dirname(target);
-    const randomHex = options?.randomHex ?? randomHex8;
-    let tempPath;
-    for (let attempt = 0; attempt < maxTempRetries; attempt += 1) {
-        const candidate = path.join(directory, `.tmp.${randomHex()}`);
-        try {
-            fs.writeFileSync(candidate, content, { flag: "wx" });
-            tempPath = candidate;
-            break;
-        }
-        catch (error) {
-            if (isErrnoException(error) && error.code === "EEXIST") {
-                continue;
-            }
-            throw error;
-        }
-    }
-    if (tempPath === undefined) {
-        throw new ProjectionStateError(`failed to create exclusive temp file for ${target} after ${maxTempRetries} retries (PROJECTION_STATE_ERROR)`);
-    }
-    try {
-        try {
-            fs.linkSync(tempPath, target);
-            return "published";
-        }
-        catch (error) {
-            if (isErrnoException(error) && error.code === "EEXIST") {
-                return "taken";
-            }
-            throw error;
-        }
-    }
-    finally {
-        try {
-            fs.unlinkSync(tempPath);
-        }
-        catch {
-            // Orphan temp is allowed; no GC.
-        }
-    }
-}