@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/repository-ledger/codec.js

@@ -1,303 +0,0 @@
-import { z } from "zod";
-import { verificationDeclarationSchema } from "../verification-declaration.js";
-export const REPOSITORY_LEDGER_REF = "refs/heads/keiyaku-ledger";
-export const REPOSITORY_DELIVERY_REF_PREFIX = "refs/heads/keiyaku/";
-export function repositoryDeliveryRef(contract) {
-    return `${REPOSITORY_DELIVERY_REF_PREFIX}${contract}`;
-}
-const UTC_RFC3339_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
-const CONTRACT_RE = /^\S+$/;
-const LIFECYCLE_SUBJECT_RE = /^keiyaku: (bind|bootstrap|arc|seal|amend|renew|petition|verdict|claim|forfeit) (\S+)$/;
-const JOIN_SUBJECT = "keiyaku: join";
-const TRANSACTION_SUBJECT = "keiyaku: transaction";
-const nonblank = z.string().refine((value) => value.trim().length > 0, "expected a nonblank string");
-const contractId = z.string().regex(CONTRACT_RE, "contract ID must be nonempty and contain no whitespace");
-const timestamp = z.string()
-    .regex(UTC_RFC3339_RE, "expected UTC RFC-3339 seconds or milliseconds")
-    .refine((value) => {
-    const milliseconds = Date.parse(value);
-    if (!Number.isFinite(milliseconds))
-        return false;
-    const canonical = new Date(milliseconds).toISOString();
-    return value.includes(".") ? canonical === value : canonical.replace(".000Z", "Z") === value;
-}, "expected a real UTC calendar date and time");
-export const fullBranchRefSchema = z.string().regex(/^refs\/heads\/\S+$/, "expected a full refs/heads name");
-const safePositiveInteger = z.number().int().positive().refine(Number.isSafeInteger, "expected a positive safe integer");
-const safeNonnegativeInteger = z.number().int().nonnegative().refine(Number.isSafeInteger, "expected a nonnegative safe integer");
-const place = z.string().regex(/^[a-z]{2,13}(?:[2-9]|[1-9][0-9]+)?$/, "expected a canonical worktree place");
-function utf8Length(value) {
-    return new TextEncoder().encode(value).byteLength;
-}
-function objectIdSchema(format) {
-    const length = format === "sha1" ? 40 : 64;
-    return z.string().regex(new RegExp(`^[0-9a-f]{${length}}$`, "i"), `expected a full ${format} object ID`);
-}
-function lifecycleEnvelope(kind, version, data) {
-    return z.object({
-        v: z.literal(version),
-        kind: z.literal(kind),
-        contract: contractId,
-        at: timestamp,
-        actor: nonblank,
-        data,
-    }).strict();
-}
-function buildLifecycleEntrySchema(format) {
-    const oid = objectIdSchema(format);
-    const extension = z.object({ title: nonblank, content: z.string() }).strict();
-    const bootstrapPlan = z.object({
-        command: z.array(nonblank).min(1),
-        timeoutMs: safePositiveInteger.max(3_600_000),
-    }).strict();
-    const bootstrapResult = z.discriminatedUnion("kind", [
-        z.object({ kind: z.literal("exit"), code: z.number().int().min(0).max(255) }).strict(),
-        z.object({ kind: z.literal("signal"), signal: nonblank }).strict(),
-        z.object({ kind: z.literal("timeout") }).strict(),
-        z.object({ kind: z.literal("spawn"), message: z.string() }).strict(),
-    ]);
-    const bindCommon = {
-        title: nonblank,
-        context: nonblank,
-        objective: nonblank,
-        design: nonblank,
-        scope: z.array(nonblank).min(1),
-        criteria: z.array(nonblank),
-        verification: z.array(verificationDeclarationSchema),
-        extensions: z.array(extension),
-        base: oid,
-        target: fullBranchRefSchema,
-    };
-    const bindData = z.discriminatedUnion("workspace", [
-        z.object({
-            ...bindCommon,
-            workspace: z.literal("worktree"),
-            after: z.array(contractId).min(1).optional(),
-            place,
-            bootstrap: bootstrapPlan.optional(),
-            taskIds: z.array(nonblank).min(1).optional(),
-        }).strict(),
-        z.object({
-            ...bindCommon,
-            workspace: z.literal("here"),
-            after: z.array(contractId).min(1).optional(),
-            taskIds: z.array(nonblank).min(1).optional(),
-        }).strict(),
-    ]);
-    const bootstrapData = z.object({
-        result: bootstrapResult,
-        durationMs: safeNonnegativeInteger,
-        stderrTail: z.string().optional(),
-        stderrTruncated: z.boolean().optional(),
-    }).strict().superRefine((value, context) => {
-        if (value.stderrTail !== undefined && utf8Length(value.stderrTail) > 2048) {
-            context.addIssue({ code: "custom", path: ["stderrTail"], message: "stderrTail exceeds 2048 UTF-8 bytes" });
-        }
-        if (value.result.kind === "spawn" && utf8Length(value.result.message) > 2048) {
-            context.addIssue({ code: "custom", path: ["result", "message"], message: "spawn message exceeds 2048 UTF-8 bytes" });
-        }
-        const successful = value.result.kind === "exit" && value.result.code === 0;
-        if (successful && (value.stderrTail !== undefined || value.stderrTruncated !== undefined)) {
-            context.addIssue({ code: "custom", message: "successful bootstrap must discard stderr facts" });
-        }
-        if (value.stderrTruncated === true && value.stderrTail === undefined) {
-            context.addIssue({ code: "custom", path: ["stderrTruncated"], message: "truncated stderr requires a retained tail" });
-        }
-    });
-    return z.discriminatedUnion("kind", [
-        lifecycleEnvelope("bind", 3, bindData),
-        lifecycleEnvelope("bootstrap", 1, bootstrapData),
-        lifecycleEnvelope("arc", 1, z.object({
-            arc: safePositiveInteger,
-            title: nonblank,
-            objective: nonblank,
-            brief: nonblank,
-        }).strict()),
-        lifecycleEnvelope("seal", 2, z.object({
-            arc: safeNonnegativeInteger,
-            sealedBy: z.enum(["arc", "renew", "petition"]),
-            oldFence: oid,
-            receipts: z.array(oid),
-            newFence: oid,
-            diffstat: z.object({
-                files: safeNonnegativeInteger,
-                insertions: safeNonnegativeInteger,
-                deletions: safeNonnegativeInteger,
-            }).strict(),
-            scopeAudit: z.object({ violations: z.array(nonblank) }).strict(),
-        }).strict()),
-        lifecycleEnvelope("amend", 2, z.object({
-            amendment: z.string(),
-            scopeDelta: z.object({ add: z.array(nonblank).min(1) }).strict().optional(),
-            verificationDelta: z.object({ replace: z.array(verificationDeclarationSchema) }).strict().optional(),
-        }).strict().superRefine((value, context) => {
-            if (!value.amendment.trim() && !value.scopeDelta && !value.verificationDelta) {
-                context.addIssue({ code: "custom", message: "amend requires prose, a scope delta, or a verification delta" });
-            }
-        })),
-        lifecycleEnvelope("renew", 1, z.object({
-            oldBase: oid,
-            newBase: oid,
-            oldHead: oid,
-            newHead: oid,
-        }).strict()),
-        lifecycleEnvelope("petition", 2, z.discriminatedUnion("intent", [
-            z.object({
-                intent: z.literal("claim"),
-                oath: nonblank,
-                target: fullBranchRefSchema,
-                targetHead: oid,
-                seat: safePositiveInteger,
-            }).strict(),
-            z.object({
-                intent: z.literal("forfeit"),
-                target: fullBranchRefSchema,
-                seat: safePositiveInteger,
-            }).strict(),
-        ])),
-        lifecycleEnvelope("verdict", 1, z.object({
-            result: z.enum(["approved", "rejected"]),
-            summary: nonblank,
-        }).strict()),
-        lifecycleEnvelope("claim", 2, z.object({
-            target: fullBranchRefSchema,
-            base: oid,
-            targetHead: oid,
-            deliveryHead: oid,
-            mergeCommit: oid,
-        }).strict()),
-        lifecycleEnvelope("forfeit", 2, z.object({
-            reason: z.enum(["manual", "bind-failed"]),
-            actor: nonblank,
-            finalHead: oid,
-            note: nonblank.optional(),
-        }).strict()),
-    ]);
-}
-const lifecycleEntrySchemas = new Map();
-export function createLifecycleEntrySchema(format) {
-    const cached = lifecycleEntrySchemas.get(format);
-    if (cached)
-        return cached;
-    const schema = buildLifecycleEntrySchema(format);
-    lifecycleEntrySchemas.set(format, schema);
-    return schema;
-}
-export const structuralJoinSchema = z.object({
-    v: z.literal(1),
-    kind: z.literal("join"),
-    at: timestamp,
-    actor: nonblank,
-}).strict();
-export const lifecycleTransactionSchema = z.object({
-    v: z.literal(1),
-    kind: z.literal("transaction"),
-    verb: z.enum(["bind", "bootstrap", "amend", "arc", "seal", "renew", "petition", "verdict", "claim", "forfeit"]),
-    predecessor: z.enum(["none", "p1"]),
-}).strict();
-export class RepositoryLedgerCodecError extends Error {
-    reason;
-    code = "INVALID_REPOSITORY_LEDGER_CODEC";
-    constructor(reason, message, options) {
-        super(message, options);
-        this.reason = reason;
-        this.name = "RepositoryLedgerCodecError";
-    }
-}
-function canonicalMessage(subject, value) {
-    return `${subject}\n\n${JSON.stringify(value, null, 2)}\n`;
-}
-export function classifyRepositoryLedgerSubject(message) {
-    const end = message.indexOf("\n");
-    const subject = end < 0 ? message : message.slice(0, end);
-    if (subject === JOIN_SUBJECT)
-        return { type: "join" };
-    if (subject === TRANSACTION_SUBJECT)
-        return { type: "transaction" };
-    const match = LIFECYCLE_SUBJECT_RE.exec(subject);
-    if (!match)
-        return { type: "unknown" };
-    return { type: "lifecycle", kind: match[1], contract: match[2] };
-}
-export function formatLifecycleEntry(entry, format) {
-    const parsed = createLifecycleEntrySchema(format).safeParse(entry);
-    if (!parsed.success) {
-        throw new RepositoryLedgerCodecError("schema", `lifecycle schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-    }
-    return canonicalMessage(`keiyaku: ${parsed.data.kind} ${parsed.data.contract}`, parsed.data);
-}
-export function formatStructuralJoin(join) {
-    const parsed = structuralJoinSchema.safeParse(join);
-    if (!parsed.success) {
-        throw new RepositoryLedgerCodecError("schema", `join schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-    }
-    return canonicalMessage(JOIN_SUBJECT, parsed.data);
-}
-export function formatLifecycleTransaction(transaction) {
-    const parsed = lifecycleTransactionSchema.safeParse(transaction);
-    if (!parsed.success) {
-        throw new RepositoryLedgerCodecError("schema", `transaction schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-    }
-    return canonicalMessage(TRANSACTION_SUBJECT, parsed.data);
-}
-export function parseRepositoryLedgerMessage(message, format) {
-    if (message.startsWith("\uFEFF") || message.includes("\r")) {
-        throw new RepositoryLedgerCodecError("format", "ledger message must be canonical UTF-8 with LF line endings and no BOM");
-    }
-    const separator = message.indexOf("\n\n");
-    if (separator < 0 || !message.endsWith("\n")) {
-        throw new RepositoryLedgerCodecError("format", "ledger message must contain one subject, one blank line, JSON, and a final LF");
-    }
-    const subject = message.slice(0, separator);
-    const body = message.slice(separator + 2, -1);
-    let json;
-    try {
-        json = JSON.parse(body);
-    }
-    catch (error) {
-        throw new RepositoryLedgerCodecError("format", "ledger JSON is invalid", { cause: error });
-    }
-    if (subject === JOIN_SUBJECT) {
-        const parsed = structuralJoinSchema.safeParse(json);
-        if (!parsed.success) {
-            throw new RepositoryLedgerCodecError("schema", `join schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-        }
-        if (message !== canonicalMessage(JOIN_SUBJECT, parsed.data)) {
-            throw new RepositoryLedgerCodecError("noncanonical", "join message bytes are not canonical");
-        }
-        return parsed.data;
-    }
-    if (subject === TRANSACTION_SUBJECT) {
-        const parsed = lifecycleTransactionSchema.safeParse(json);
-        if (!parsed.success) {
-            throw new RepositoryLedgerCodecError("schema", `transaction schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-        }
-        if (message !== canonicalMessage(TRANSACTION_SUBJECT, parsed.data)) {
-            throw new RepositoryLedgerCodecError("noncanonical", "transaction message bytes are not canonical");
-        }
-        return parsed.data;
-    }
-    const subjectMatch = LIFECYCLE_SUBJECT_RE.exec(subject);
-    if (!subjectMatch) {
-        throw new RepositoryLedgerCodecError("format", "ledger subject is not a lifecycle entry, transaction, or structural join");
-    }
-    const parsed = createLifecycleEntrySchema(format).safeParse(json);
-    if (!parsed.success) {
-        throw new RepositoryLedgerCodecError("schema", `lifecycle schema validation failed: ${parsed.error.message}`, { cause: parsed.error });
-    }
-    if (parsed.data.kind !== subjectMatch[1] || parsed.data.contract !== subjectMatch[2]) {
-        throw new RepositoryLedgerCodecError("format", "lifecycle subject does not match its JSON body");
-    }
-    if (message !== canonicalMessage(`keiyaku: ${parsed.data.kind} ${parsed.data.contract}`, parsed.data)) {
-        throw new RepositoryLedgerCodecError("noncanonical", "lifecycle message bytes are not canonical");
-    }
-    return parsed.data;
-}
-export function evidenceObjectId(entry) {
-    switch (entry.kind) {
-        case "seal": return entry.data.newFence;
-        case "renew": return entry.data.oldHead;
-        case "claim": return entry.data.mergeCommit;
-        case "forfeit": return entry.data.finalHead;
-        default: return null;
-    }
-}