@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/cli/square-edge.js

@@ -1,159 +0,0 @@
-import { bindCurrentParticipant, createHostLedgerPort, Square, squareAssignedParticipantName, } from "@astrosheep/square";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { keiyakuSquarePath } from "../world.js";
-async function openKeiyakuSquare(path, environment, hostLedger) {
-    try {
-        return await Square.at({ path, env: environment, hostLedger });
-    }
-    catch (error) {
-        if (error.code !== "ENOENT" && error.code !== "unavailable")
-            throw error;
-        try {
-            return await Square.build({ path, markdown: "", env: environment, hostLedger });
-        }
-        catch (buildError) {
-            try {
-                return await Square.at({ path, env: environment, hostLedger });
-            }
-            catch {
-                throw buildError;
-            }
-        }
-    }
-}
-function squareInvocationEnvironment(environment, path) {
-    const ledgerRoot = environment.SQUARE_REGISTRY === undefined ? undefined : dirname(environment.SQUARE_REGISTRY);
-    return {
-        ...environment,
-        SQUARE_HOST_LEDGER_USER: environment.SQUARE_HOST_LEDGER_USER ?? ledgerRoot ?? join(homedir(), ".square", "host-ledger"),
-        SQUARE_HOST_LEDGER_LOCAL: environment.SQUARE_HOST_LEDGER_LOCAL ??
-            ledgerRoot ??
-            join(environment.PWD ?? dirname(path), ".square", "host-ledger"),
-    };
-}
-function invocationHostLedger(environment) {
-    return createHostLedgerPort({
-        userPath: environment.SQUARE_HOST_LEDGER_USER,
-        localPath: environment.SQUARE_HOST_LEDGER_LOCAL,
-    });
-}
-async function participantBindings(hostLedger, path, name) {
-    return await hostLedger.listPresence({ location: path, participant: name });
-}
-function presenceKey({ location, participant, session, channel }) {
-    return JSON.stringify([location, participant, session, channel]);
-}
-function exactPresenceKey({ location, participant, session, channel }) {
-    return { location, participant, session, channel };
-}
-async function bestEffort(operation) {
-    try {
-        await operation();
-    }
-    catch { }
-}
-async function rollbackSquareEdge(input) {
-    const { path, environment, hostLedger, name, allocated, joined, listening, createdBindings } = input;
-    if (listening || joined) {
-        let square;
-        await bestEffort(async () => {
-            square = await Square.at({ path, env: environment, hostLedger });
-        });
-        let participant;
-        if (square !== undefined)
-            await bestEffort(async () => {
-                participant = await square.join(name);
-            });
-        if (participant !== undefined && listening)
-            await bestEffort(async () => participant.ignore(allocated.id));
-        if (participant !== undefined && joined)
-            await bestEffort(async () => participant.done());
-        if (square !== undefined)
-            await bestEffort(async () => square.close());
-    }
-    for (const binding of createdBindings)
-        await bestEffort(async () => hostLedger.removePresence(binding));
-}
-export async function recognizeAndListen(worldRoot, environment, allocated) {
-    const path = keiyakuSquarePath(worldRoot);
-    const squareEnvironment = squareInvocationEnvironment(environment, path);
-    let name;
-    try {
-        const assigned = squareAssignedParticipantName(squareEnvironment);
-        if (assigned === undefined)
-            return;
-        name = assigned;
-    }
-    catch {
-        return;
-    }
-    const hostLedger = invocationHostLedger(squareEnvironment);
-    let joined = false;
-    let listening = false;
-    let bindingsBeforeCall = [];
-    let hasBindingSnapshot = false;
-    let createdBindings = [];
-    const rememberCreatedBindings = async () => {
-        const beforeKeys = new Set(bindingsBeforeCall.map(presenceKey));
-        createdBindings = (await participantBindings(hostLedger, path, name))
-            .filter((binding) => !beforeKeys.has(presenceKey(binding)))
-            .map(exactPresenceKey);
-    };
-    const refreshCreatedBindings = async () => {
-        try {
-            await rememberCreatedBindings();
-        }
-        catch { }
-    };
-    const rollback = async () => await rollbackSquareEdge({
-        path,
-        environment: squareEnvironment,
-        hostLedger,
-        name,
-        allocated,
-        joined,
-        listening,
-        createdBindings,
-    });
-    let square;
-    try {
-        bindingsBeforeCall = await participantBindings(hostLedger, path, name);
-        hasBindingSnapshot = true;
-        square = await openKeiyakuSquare(path, squareEnvironment, hostLedger);
-        const joinedResult = await square.joinWithActivity(name);
-        joined = joinedResult.activity !== null;
-        const participant = joinedResult.participant;
-        await bindCurrentParticipant(path, name, squareEnvironment);
-        await rememberCreatedBindings();
-        const listener = participant;
-        let change;
-        try {
-            change = await listener.listen(allocated.id);
-        }
-        catch {
-            // Keep birth independent from an older or drifting Square name grammar.
-            await refreshCreatedBindings();
-            await rollback();
-            return;
-        }
-        listening = change.activity !== null;
-        await square.close();
-        square = undefined;
-        return {
-            committed: true,
-            participantName: name,
-            rollback,
-        };
-    }
-    catch {
-        if (hasBindingSnapshot)
-            await refreshCreatedBindings();
-        await rollback();
-        return;
-    }
-    finally {
-        if (square !== undefined)
-            await square.close().catch(() => undefined);
-    }
-}

package/build/src/git/ref-migration.d.ts

@@ -1,22 +0,0 @@
-import type { ContractId } from "../core/facts/types.js";
-import { type GitRepository } from "./process.js";
-import { type GitOid } from "./repository.js";
-export type RefMigrationEffect = Readonly<{
-    kind: "ref";
-    name: string;
-    before: GitOid | null;
-    after: GitOid | null;
-    action: "created" | "removed";
-}>;
-export type RefMigrationConflict = Readonly<{
-    kind: "ref-migration-conflict";
-    legacyRef: string;
-    legacyOid: GitOid;
-    currentRef: string;
-    currentOid: GitOid;
-}>;
-export type RefMigrationResult = Readonly<{
-    effects: readonly RefMigrationEffect[];
-    lag: readonly RefMigrationConflict[];
-}>;
-export declare function migrateContractCustodyRefs(repository: GitRepository, contract: ContractId): Promise<RefMigrationResult>;

package/build/src/git/ref-migration.js

@@ -1,55 +0,0 @@
-import { contractPhysicalName } from "./identity.js";
-import { runGit } from "./process.js";
-import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, LEGACY_CANDIDATE_PIN_REF_NAMESPACE, LEGACY_DELIVERY_REF_NAMESPACE, readRef, } from "./repository.js";
-export async function migrateContractCustodyRefs(repository, contract) {
-    const leaf = contractPhysicalName(contract);
-    const pairs = [
-        {
-            legacy: `${LEGACY_DELIVERY_REF_NAMESPACE}/${leaf}`,
-            current: `${DELIVERY_REF_NAMESPACE}/${leaf}`,
-        },
-        {
-            legacy: `${LEGACY_CANDIDATE_PIN_REF_NAMESPACE}/${leaf}`,
-            current: `${CANDIDATE_PIN_REF_NAMESPACE}/${leaf}`,
-        },
-    ];
-    const observed = await Promise.all(pairs.map(async (pair) => {
-        const [legacyOid, currentOid] = await Promise.all([
-            readRef(repository, pair.legacy),
-            readRef(repository, pair.current),
-        ]);
-        return { ...pair, legacyOid, currentOid };
-    }));
-    const lag = observed.flatMap((pair) => pair.legacyOid !== null && pair.currentOid !== null && pair.currentOid !== pair.legacyOid
-        ? [
-            {
-                kind: "ref-migration-conflict",
-                legacyRef: pair.legacy,
-                legacyOid: pair.legacyOid,
-                currentRef: pair.current,
-                currentOid: pair.currentOid,
-            },
-        ]
-        : []);
-    if (lag.length > 0)
-        return { effects: [], lag };
-    const migrating = observed.filter((pair) => pair.legacyOid !== null);
-    if (migrating.length === 0)
-        return { effects: [], lag: [] };
-    const lines = ["start"];
-    const effects = [];
-    for (const pair of migrating) {
-        if (pair.currentOid === null) {
-            lines.push(`create ${pair.current} ${pair.legacyOid}`);
-            effects.push({ kind: "ref", name: pair.current, before: null, after: pair.legacyOid, action: "created" });
-        }
-        else {
-            lines.push(`verify ${pair.current} ${pair.currentOid}`);
-        }
-        lines.push(`delete ${pair.legacy} ${pair.legacyOid}`);
-        effects.push({ kind: "ref", name: pair.legacy, before: pair.legacyOid, after: null, action: "removed" });
-    }
-    lines.push("prepare", "commit", "");
-    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], lines.join("\n"));
-    return { effects, lag: [] };
-}

package/build/src/library/contract-forwarding-reconciliation-result.d.ts

@@ -1,102 +0,0 @@
-import { z } from "zod";
-export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"worktree-retained">;
-    path: z.ZodString;
-}, z.core.$strict>, z.ZodPipe<z.ZodObject<{
-    kind: z.ZodLiteral<"worktree-follow-retained">;
-    path: z.ZodString;
-    tender: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
-    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
-    reason: z.ZodEnum<{
-        "head-moved": "head-moved";
-        "head-attached": "head-attached";
-        "operation-in-progress": "operation-in-progress";
-        "unsupported-parent-shape": "unsupported-parent-shape";
-    }>;
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>, z.ZodTransform<{
-    kind: "worktree-follow-retained";
-    path: string;
-    tender: import("./contract.js").SnapshotId;
-    head: import("./contract.js").SnapshotId;
-    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
-} | {
-    paths: string[];
-    kind: "worktree-follow-retained";
-    path: string;
-    tender: import("./contract.js").SnapshotId;
-    head: import("./contract.js").SnapshotId;
-    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
-}, {
-    kind: "worktree-follow-retained";
-    path: string;
-    tender: import("./contract.js").SnapshotId;
-    head: import("./contract.js").SnapshotId;
-    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
-    paths?: string[] | undefined;
-}>>, z.ZodPipe<z.ZodObject<{
-    kind: z.ZodLiteral<"unsealed-bytes">;
-    path: z.ZodString;
-    paths: z.ZodArray<z.ZodString>;
-    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>>;
-}, z.core.$strict>, z.ZodTransform<{
-    kind: "unsealed-bytes";
-    path: string;
-    paths: string[];
-} | {
-    head: import("./contract.js").SnapshotId;
-    kind: "unsealed-bytes";
-    path: string;
-    paths: string[];
-}, {
-    kind: "unsealed-bytes";
-    path: string;
-    paths: string[];
-    head?: import("./contract.js").SnapshotId | undefined;
-}>>, z.ZodObject<{
-    kind: z.ZodLiteral<"target-checkout-retained">;
-    path: z.ZodString;
-    target: z.ZodString;
-    diagnostic: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"reconcile-failed">;
-    stage: z.ZodEnum<{
-        observation: "observation";
-        effect: "effect";
-    }>;
-    diagnostic: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"ref-migration-conflict">;
-    legacyRef: z.ZodString;
-    legacyOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
-    currentRef: z.ZodString;
-    currentOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"worktree-hook-failed">;
-    phase: z.ZodEnum<{
-        destroy: "destroy";
-        create: "create";
-    }>;
-    path: z.ZodString;
-    command: z.ZodNumber;
-    name: z.ZodString;
-    failure: z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"exit">;
-        code: z.ZodNumber;
-        stdout: z.ZodString;
-        stderr: z.ZodString;
-        truncated: z.ZodBoolean;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"timeout">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"spawn-error">;
-        diagnostic: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"unknown-exit">;
-    }, z.core.$strict>]>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"contract-file-failed">;
-    worktree: z.ZodString;
-    path: z.ZodString;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;

package/build/src/library/contract-forwarding-reconciliation-result.js

@@ -1,92 +0,0 @@
-import { mintSnapshotId } from "../git/identity.js";
-import { z } from "zod";
-function canonicalSnapshot(value, context) {
-    try {
-        return mintSnapshotId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected SnapshotId" });
-        return z.NEVER;
-    }
-}
-const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
-const snapshotIdSchema = z.string().transform(canonicalSnapshot);
-const hookFailureSchema = z.union([
-    z
-        .object({
-        kind: z.literal("exit"),
-        code: z.number().int(),
-        stdout: z.string(),
-        stderr: z.string(),
-        truncated: z.boolean(),
-    })
-        .strict(),
-    z.object({ kind: z.literal("timeout") }).strict(),
-    z.object({ kind: z.literal("spawn-error"), diagnostic: z.string() }).strict(),
-    z.object({ kind: z.literal("unknown-exit") }).strict(),
-]);
-export const reconciliationLagSchema = z.union([
-    z.object({ kind: z.literal("worktree-retained"), path: nonblankStringSchema }).strict(),
-    z
-        .object({
-        kind: z.literal("worktree-follow-retained"),
-        path: nonblankStringSchema,
-        tender: snapshotIdSchema,
-        head: snapshotIdSchema,
-        reason: z.enum(["head-moved", "head-attached", "operation-in-progress", "unsupported-parent-shape"]),
-        paths: z.array(nonblankStringSchema).optional(),
-    })
-        .strict()
-        .transform(({ paths, ...lag }) => (paths === undefined ? lag : { ...lag, paths })),
-    z
-        .object({
-        kind: z.literal("unsealed-bytes"),
-        path: nonblankStringSchema,
-        paths: z.array(nonblankStringSchema),
-        head: snapshotIdSchema.optional(),
-    })
-        .strict()
-        .transform(({ head, ...lag }) => (head === undefined ? lag : { ...lag, head })),
-    z
-        .object({
-        kind: z.literal("target-checkout-retained"),
-        path: nonblankStringSchema,
-        target: nonblankStringSchema,
-        diagnostic: nonblankStringSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("reconcile-failed"),
-        stage: z.enum(["observation", "effect"]),
-        diagnostic: nonblankStringSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("ref-migration-conflict"),
-        legacyRef: nonblankStringSchema,
-        legacyOid: snapshotIdSchema,
-        currentRef: nonblankStringSchema,
-        currentOid: snapshotIdSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("worktree-hook-failed"),
-        phase: z.enum(["create", "destroy"]),
-        path: nonblankStringSchema,
-        command: z.number().int().nonnegative(),
-        name: nonblankStringSchema,
-        failure: hookFailureSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("contract-file-failed"),
-        worktree: nonblankStringSchema,
-        path: nonblankStringSchema,
-        diagnostic: nonblankStringSchema,
-    })
-        .strict(),
-]);