@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/projection/heart.js

@@ -0,0 +1,316 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { isErrnoException } from "../../errno.js";
+export const HEART_FILE = "heart";
+const HEART_SCHEMA_VERSION = 1;
+export const HEART_BUSY_TIMEOUT_MS = 5_000;
+export class ProjectionHeartError extends Error {
+    code = "PROJECTION_HEART_ERROR";
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProjectionHeartError";
+    }
+}
+const HEART_SCHEMA_SQL = `
+  CREATE TABLE heart_schema (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = ${HEART_SCHEMA_VERSION})
+  ) STRICT
+`;
+const IDENTITY_TABLE_SQL = `
+  CREATE TABLE projection_identity (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = 1),
+    pid INTEGER NOT NULL CHECK (pid >= 0),
+    akuma TEXT NOT NULL CHECK (length(trim(akuma)) > 0),
+    provider TEXT NOT NULL CHECK (length(trim(provider)) > 0),
+    authority_json TEXT NOT NULL CHECK (json_valid(authority_json)),
+    binding_json TEXT NOT NULL CHECK (json_valid(binding_json)),
+    minted_at TEXT NOT NULL CHECK (length(trim(minted_at)) > 0),
+    workspace_root TEXT NOT NULL CHECK (length(trim(workspace_root)) > 0),
+    effective_policy_json TEXT CHECK (
+      effective_policy_json IS NULL OR json_valid(effective_policy_json)
+    )
+  ) STRICT
+`;
+const RECORD_TABLE_SQL = `
+  CREATE TABLE generation_records (
+    seq INTEGER PRIMARY KEY CHECK (seq > 0),
+    kind TEXT NOT NULL CHECK (kind IN ('launch', 'adoption', 'verdict')),
+    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+    payload_json TEXT NOT NULL CHECK (json_valid(payload_json))
+  ) STRICT
+`;
+const TELL_TABLE_SQL = `
+  CREATE TABLE projection_tells (
+    tell_id TEXT PRIMARY KEY CHECK (length(trim(tell_id)) > 0),
+    text TEXT NOT NULL,
+    created_at TEXT NOT NULL CHECK (length(trim(created_at)) > 0),
+    effort TEXT CHECK (effort IS NULL OR length(trim(effort)) > 0),
+    state TEXT NOT NULL CHECK (
+      state IN ('inbox', 'inflight', 'submitted', 'consumed', 'delivered')
+    ),
+    execution_id TEXT CHECK (
+      execution_id IS NULL OR length(trim(execution_id)) > 0
+    ),
+    fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
+    replayed_from_json TEXT CHECK (
+      replayed_from_json IS NULL OR json_valid(replayed_from_json)
+    ),
+    delivered_at TEXT CHECK (
+      delivered_at IS NULL OR length(trim(delivered_at)) > 0
+    )
+  ) STRICT
+`;
+const EXPECTED_OBJECT_SIGNATURE = "table:generation_records,table:heart_schema,table:projection_identity,table:projection_tells";
+const EXPECTED_RECORD_COLUMNS = "seq:INTEGER:0:1,kind:TEXT:1:0,execution_id:TEXT:1:0,payload_json:TEXT:1:0";
+const EXPECTED_IDENTITY_COLUMNS = "singleton:INTEGER:0:1,version:INTEGER:1:0,pid:INTEGER:1:0,akuma:TEXT:1:0,provider:TEXT:1:0,authority_json:TEXT:1:0,binding_json:TEXT:1:0,minted_at:TEXT:1:0,workspace_root:TEXT:1:0,effective_policy_json:TEXT:0:0";
+const EXPECTED_TELL_COLUMNS = "tell_id:TEXT:1:1,text:TEXT:1:0,created_at:TEXT:1:0,effort:TEXT:0:0,state:TEXT:1:0,execution_id:TEXT:0:0,fence_json:TEXT:0:0,replayed_from_json:TEXT:0:0,delivered_at:TEXT:0:0";
+export function heartPath(projectionDirectory) {
+    return path.join(projectionDirectory, HEART_FILE);
+}
+function rollbackQuietly(database) {
+    try {
+        database.exec("ROLLBACK");
+    }
+    catch {
+        // Preserve the write or schema failure that caused the rollback.
+    }
+}
+function assertParentDirectory(projectionDirectory) {
+    let stat;
+    try {
+        stat = fs.statSync(projectionDirectory);
+    }
+    catch (error) {
+        throw new ProjectionHeartError(`projection heart parent directory does not exist at ${projectionDirectory}`, { cause: error });
+    }
+    if (!stat.isDirectory()) {
+        throw new ProjectionHeartError("projection heart parent must be a directory");
+    }
+}
+function assertRegularHeartFile(databasePath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(databasePath);
+    }
+    catch (error) {
+        throw new ProjectionHeartError(`projection heart does not exist at ${databasePath}`, { cause: error });
+    }
+    if (!stat.isFile()) {
+        throw new ProjectionHeartError("projection heart must be a regular file");
+    }
+}
+export function configureHeartBusyTimeout(database) {
+    database.exec(`PRAGMA busy_timeout = ${HEART_BUSY_TIMEOUT_MS}`);
+}
+function configureWritable(database) {
+    configureHeartBusyTimeout(database);
+    database.exec("PRAGMA journal_mode = DELETE");
+    database.exec("PRAGMA synchronous = FULL");
+    database.exec("PRAGMA foreign_keys = ON");
+    database.exec("PRAGMA trusted_schema = OFF");
+}
+function columnSignature(database, table) {
+    const columns = database.prepare(`PRAGMA table_info(${table})`).all();
+    return columns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+}
+function validateSchemaShape(database) {
+    const objects = database.prepare(`
+    SELECT name, type
+    FROM sqlite_schema
+    WHERE name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all();
+    const signature = objects.map((object) => `${object.type}:${object.name}`).join(",");
+    if (signature !== EXPECTED_OBJECT_SIGNATURE) {
+        throw new ProjectionHeartError(`projection heart schema contains unexpected objects: ${signature || "none"}`);
+    }
+    const metadata = database.prepare("SELECT singleton, version FROM heart_schema").all();
+    if (metadata.length !== 1
+        || Number(metadata[0].singleton) !== 1
+        || Number(metadata[0].version) !== HEART_SCHEMA_VERSION) {
+        throw new ProjectionHeartError("projection heart schema metadata is malformed");
+    }
+    if (columnSignature(database, "generation_records") !== EXPECTED_RECORD_COLUMNS) {
+        throw new ProjectionHeartError("projection heart generation_records schema is malformed");
+    }
+    if (columnSignature(database, "projection_identity") !== EXPECTED_IDENTITY_COLUMNS) {
+        throw new ProjectionHeartError("projection heart projection_identity schema is malformed");
+    }
+    if (columnSignature(database, "projection_tells") !== EXPECTED_TELL_COLUMNS) {
+        throw new ProjectionHeartError("projection heart projection_tells schema is malformed");
+    }
+    const quickCheck = database.prepare("PRAGMA quick_check").get();
+    if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
+        throw new ProjectionHeartError("projection heart database failed quick_check");
+    }
+}
+function installSchema(database) {
+    database.exec("BEGIN EXCLUSIVE");
+    try {
+        const objects = database.prepare(`
+      SELECT name, type
+      FROM sqlite_schema
+      WHERE name NOT LIKE 'sqlite_%'
+      ORDER BY name
+    `).all();
+        if (objects.length !== 0) {
+            throw new ProjectionHeartError("projection heart already contains schema objects");
+        }
+        database.exec(HEART_SCHEMA_SQL);
+        database.exec(IDENTITY_TABLE_SQL);
+        database.exec(RECORD_TABLE_SQL);
+        database.exec(TELL_TABLE_SQL);
+        database.prepare("INSERT INTO heart_schema (singleton, version) VALUES (1, ?)")
+            .run(HEART_SCHEMA_VERSION);
+        validateSchemaShape(database);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        rollbackQuietly(database);
+        throw error;
+    }
+}
+export class ProjectionHeart {
+    databasePath;
+    readOnly;
+    #database;
+    #closed = false;
+    constructor(databasePath, database, readOnly) {
+        this.databasePath = databasePath;
+        this.#database = database;
+        this.readOnly = readOnly;
+    }
+    /** Create a brand-new heart database with schema v1. Fails if the file already exists. */
+    static create(projectionDirectory) {
+        assertParentDirectory(projectionDirectory);
+        const databasePath = heartPath(projectionDirectory);
+        let reserved = false;
+        try {
+            const fd = fs.openSync(databasePath, "wx");
+            fs.closeSync(fd);
+            reserved = true;
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === "EEXIST") {
+                throw new ProjectionHeartError(`projection heart already exists at ${databasePath}`, { cause: error });
+            }
+            throw new ProjectionHeartError(`cannot create projection heart at ${databasePath}`, { cause: error });
+        }
+        let database;
+        try {
+            database = new DatabaseSync(databasePath, {
+                enableForeignKeyConstraints: true,
+                enableDoubleQuotedStringLiterals: false,
+                allowExtension: false,
+            });
+            configureWritable(database);
+            installSchema(database);
+            return new ProjectionHeart(databasePath, database, false);
+        }
+        catch (error) {
+            try {
+                database?.close();
+            }
+            catch { /* preserve the causal create failure */ }
+            if (reserved) {
+                try {
+                    fs.unlinkSync(databasePath);
+                }
+                catch {
+                    // Leave a partial file only if unlink itself fails.
+                }
+            }
+            if (error instanceof ProjectionHeartError)
+                throw error;
+            throw new ProjectionHeartError(`cannot create projection heart at ${databasePath}`, { cause: error });
+        }
+    }
+    /** Open an existing heart read-only. Never creates, mutates, or migrates. */
+    static openReadOnly(projectionDirectory) {
+        assertParentDirectory(projectionDirectory);
+        const databasePath = heartPath(projectionDirectory);
+        assertRegularHeartFile(databasePath);
+        let database;
+        try {
+            database = new DatabaseSync(databasePath, {
+                readOnly: true,
+                enableDoubleQuotedStringLiterals: false,
+                allowExtension: false,
+            });
+            configureHeartBusyTimeout(database);
+            validateSchemaShape(database);
+            return new ProjectionHeart(databasePath, database, true);
+        }
+        catch (error) {
+            try {
+                database?.close();
+            }
+            catch { /* preserve open failure */ }
+            if (error instanceof ProjectionHeartError)
+                throw error;
+            throw new ProjectionHeartError(`cannot open projection heart at ${databasePath}`, { cause: error });
+        }
+    }
+    /** Open an existing heart for read/write. Never creates or migrates. */
+    static openWritable(projectionDirectory) {
+        assertParentDirectory(projectionDirectory);
+        const databasePath = heartPath(projectionDirectory);
+        assertRegularHeartFile(databasePath);
+        let database;
+        try {
+            database = new DatabaseSync(databasePath, {
+                enableForeignKeyConstraints: true,
+                enableDoubleQuotedStringLiterals: false,
+                allowExtension: false,
+            });
+            configureWritable(database);
+            validateSchemaShape(database);
+            return new ProjectionHeart(databasePath, database, false);
+        }
+        catch (error) {
+            try {
+                database?.close();
+            }
+            catch { /* preserve open failure */ }
+            if (error instanceof ProjectionHeartError)
+                throw error;
+            throw new ProjectionHeartError(`cannot open projection heart at ${databasePath}`, { cause: error });
+        }
+    }
+    read(fn) {
+        this.#assertOpen();
+        return fn(this.#database);
+    }
+    write(fn) {
+        this.#assertOpen();
+        if (this.readOnly) {
+            throw new ProjectionHeartError("projection heart is read-only");
+        }
+        this.#database.exec("BEGIN IMMEDIATE");
+        try {
+            const result = fn(this.#database);
+            this.#database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            rollbackQuietly(this.#database);
+            throw error;
+        }
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#database.close();
+    }
+    #assertOpen() {
+        if (this.#closed) {
+            throw new ProjectionHeartError("projection heart is closed");
+        }
+    }
+}

package/build/core/projection/identity.js

@@ -0,0 +1,81 @@
+import { parseExecutionPact, } from "../execution-pact.js";
+import { ProjectionHeartError } from "./heart.js";
+/**
+ * Insert the single immutable identity row.
+ * There is no product UPDATE path; a second insert fails.
+ */
+export function insertProjectionIdentity(heart, identity) {
+    const location = `${heart.databasePath}#projection_identity`;
+    const validated = parseExecutionPact(identity, location);
+    heart.write((database) => {
+        const existing = database.prepare("SELECT COUNT(*) AS count FROM projection_identity").get();
+        if (Number(existing?.count ?? 0) !== 0) {
+            throw new ProjectionHeartError("projection identity is already initialized");
+        }
+        database.prepare(`
+      INSERT INTO projection_identity (
+        singleton,
+        version,
+        pid,
+        akuma,
+        provider,
+        authority_json,
+        binding_json,
+        minted_at,
+        workspace_root,
+        effective_policy_json
+      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(validated.version, validated.pid, validated.akuma, validated.provider, JSON.stringify(validated.authority), JSON.stringify(validated.binding), validated.mintedAt, validated.workspaceRoot, validated.effectivePolicy === undefined
+            ? null
+            : JSON.stringify(validated.effectivePolicy));
+    });
+}
+/** Read the single immutable identity row through the existing pact parser. */
+export function readProjectionIdentity(heart) {
+    const location = `${heart.databasePath}#projection_identity`;
+    return heart.read((database) => {
+        const rows = database.prepare(`
+      SELECT
+        version,
+        pid,
+        akuma,
+        provider,
+        authority_json,
+        binding_json,
+        minted_at,
+        workspace_root,
+        effective_policy_json
+      FROM projection_identity
+    `).all();
+        if (rows.length !== 1) {
+            throw new ProjectionHeartError(`projection identity row count must be 1, found ${rows.length}`);
+        }
+        const row = rows[0];
+        let authority;
+        let binding;
+        let effectivePolicy;
+        try {
+            authority = JSON.parse(row.authority_json);
+            binding = JSON.parse(row.binding_json);
+            effectivePolicy = row.effective_policy_json === null
+                ? undefined
+                : JSON.parse(row.effective_policy_json);
+        }
+        catch (error) {
+            throw new ProjectionHeartError("projection identity contains malformed JSON", {
+                cause: error,
+            });
+        }
+        return parseExecutionPact({
+            version: Number(row.version),
+            pid: Number(row.pid),
+            akuma: row.akuma,
+            provider: row.provider,
+            authority,
+            binding,
+            mintedAt: row.minted_at,
+            workspaceRoot: row.workspace_root,
+            ...(effectivePolicy === undefined ? {} : { effectivePolicy }),
+        }, location);
+    });
+}

package/build/core/projection/leash.js

@@ -0,0 +1,87 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { isErrnoException } from "../../errno.js";
+export const LEASH_FILE = "leash";
+export class ProjectionLeashError extends Error {
+    code = "PROJECTION_LEASH_ERROR";
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProjectionLeashError";
+    }
+}
+export function leashPath(projectionDirectory) {
+    return path.join(projectionDirectory, LEASH_FILE);
+}
+function errorDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function readJournalMode(database) {
+    const row = database.prepare("PRAGMA journal_mode").get();
+    return typeof row?.journal_mode === "string" ? row.journal_mode.toLowerCase() : undefined;
+}
+/**
+ * Birth-time initialization for the projection leash file.
+ * Creates a brand-new extensionless rollback-journal SQLite database with the
+ * minimal kernel-lock anchor schema, then closes all handles before return.
+ * Fails if the target already exists. Stores zero product facts.
+ */
+export function initializeProjectionLeash(projectionDirectory) {
+    let parent;
+    try {
+        parent = fs.statSync(projectionDirectory);
+    }
+    catch (error) {
+        throw new ProjectionLeashError(`projection leash parent directory does not exist at ${projectionDirectory}`, { cause: error });
+    }
+    if (!parent.isDirectory()) {
+        throw new ProjectionLeashError("projection leash parent must be a directory");
+    }
+    const target = leashPath(projectionDirectory);
+    let reserved = false;
+    try {
+        const fd = fs.openSync(target, "wx");
+        fs.closeSync(fd);
+        reserved = true;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "EEXIST") {
+            throw new ProjectionLeashError(`projection leash already exists at ${target}`, { cause: error });
+        }
+        throw new ProjectionLeashError(`projection leash could not be initialized: ${errorDetail(error)}`, { cause: error });
+    }
+    let database;
+    try {
+        database = new DatabaseSync(target, {
+            enableDoubleQuotedStringLiterals: false,
+            allowExtension: false,
+        });
+        database.exec("PRAGMA busy_timeout = 0");
+        database.exec("PRAGMA journal_mode = DELETE");
+        database.exec("CREATE TABLE lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
+        if (readJournalMode(database) !== "delete") {
+            throw new ProjectionLeashError("projection leash does not use rollback-journal mode");
+        }
+        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
+        database.close();
+        database = undefined;
+        return target;
+    }
+    catch (error) {
+        try {
+            database?.close();
+        }
+        catch { /* preserve the causal initialization failure */ }
+        if (reserved) {
+            try {
+                fs.unlinkSync(target);
+            }
+            catch {
+                // Leave a partial file only if unlink itself fails.
+            }
+        }
+        if (error instanceof ProjectionLeashError)
+            throw error;
+        throw new ProjectionLeashError(`projection leash could not be initialized: ${errorDetail(error)}`, { cause: error });
+    }
+}

package/build/core/projection/mint.js

@@ -0,0 +1,154 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isErrnoException } from "../../errno.js";
+import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
+import { isoFromNowMs, PROJECTION_ROOT_SEGMENTS, projectionDir, projectionRoot, } from "../projection-core.js";
+import { parseExecutionAuthoritySelection, parseExecutionPact, parseExecutionPactFields, } from "../execution-pact.js";
+import { ProjectionHeart } from "./heart.js";
+import { insertProjectionIdentity } from "./identity.js";
+import { initializeProjectionLeash } from "./leash.js";
+export class ProjectionMintCollisionError extends Error {
+    code = "PROJECTION_MINT_COLLISION";
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProjectionMintCollisionError";
+    }
+}
+const DEFAULT_MINT_ATTEMPTS = 16;
+function assertMintSlug(slug) {
+    const normalized = slug.trim();
+    if (!normalized) {
+        throw new ProjectionStateError("projection slug cannot be empty");
+    }
+    if (normalized.includes("/") || normalized.includes("\0")) {
+        throw new ProjectionStateError(`invalid projection slug: ${slug}`);
+    }
+    return normalized;
+}
+/**
+ * Validate mint inputs that can fail, then reserve one private staging directory.
+ * Dot-prefixed staging is never a published projection address.
+ */
+function reserveProjectionDirectory(input) {
+    const slug = assertMintSlug(input.slug);
+    if (!Number.isInteger(input.pid) || input.pid < 0) {
+        throw new ProjectionStateError("projection pid must be a non-negative integer");
+    }
+    if (!Number.isSafeInteger(input.nowMs) || input.nowMs < 0) {
+        throw new ProjectionStateError("nowMs must be a safe non-negative integer");
+    }
+    const maxAttempts = input.maxAttempts ?? DEFAULT_MINT_ATTEMPTS;
+    if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+        throw new ProjectionStateError("maxAttempts must be a positive integer");
+    }
+    const root = projectionRoot(input.cwd);
+    fs.mkdirSync(root, { recursive: true });
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const hex = (input.randomHex?.(attempt) ?? randomHex8()).toLowerCase();
+        if (!/^[0-9a-f]{8}$/.test(hex)) {
+            throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
+        }
+        const id = `${slug}-${hex}`;
+        const dir = projectionDir(input.cwd, id);
+        const stagingDir = path.join(root, `.mint-${id}`);
+        if (fs.existsSync(dir))
+            continue;
+        try {
+            fs.mkdirSync(stagingDir);
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === "EEXIST") {
+                continue;
+            }
+            throw error;
+        }
+        if (fs.existsSync(dir)) {
+            fs.rmdirSync(stagingDir);
+            continue;
+        }
+        return { id, dir, stagingDir };
+    }
+    throw new ProjectionMintCollisionError(`exhausted ${maxAttempts} projection id attempts under ${PROJECTION_ROOT_SEGMENTS.join("/")} (PROJECTION_MINT_COLLISION)`);
+}
+/** Build the identity fields shared by both authority variants. */
+function buildMintPactFields(input) {
+    return {
+        version: 1,
+        pid: input.pid,
+        akuma: input.akuma,
+        provider: input.provider,
+        binding: input.binding,
+        mintedAt: isoFromNowMs(input.nowMs),
+        workspaceRoot: input.workspaceRoot ?? path.resolve(input.cwd),
+        ...(input.effectivePolicy ? { effectivePolicy: input.effectivePolicy } : {}),
+    };
+}
+/**
+ * Build both hard projection organs in private staging, close every database
+ * handle, then publish with one directory rename. Rename is the sole publication
+ * boundary; no fallible work runs after it.
+ */
+function publishReservedProjection(pact, reserved) {
+    let published = false;
+    try {
+        const heart = ProjectionHeart.create(reserved.stagingDir);
+        try {
+            insertProjectionIdentity(heart, pact);
+        }
+        finally {
+            heart.close();
+        }
+        initializeProjectionLeash(reserved.stagingDir);
+        fs.renameSync(reserved.stagingDir, reserved.dir);
+        published = true;
+        return { id: reserved.id, dir: reserved.dir, pact };
+    }
+    finally {
+        if (!published) {
+            // Failure removes only this mint's staging.
+            fs.rmSync(reserved.stagingDir, { recursive: true, force: true });
+        }
+    }
+}
+/**
+ * Mint a user-authority projection directory.
+ * Order: validate → reserve staging → heart + identity + leash → close → atomic rename.
+ */
+export function mintProjection(input) {
+    const authority = parseExecutionAuthoritySelection(input.authority, "projection identity", "user");
+    const fields = parseExecutionPactFields(buildMintPactFields(input));
+    const pact = parseExecutionPact({
+        version: fields.version,
+        pid: fields.pid,
+        akuma: fields.akuma,
+        provider: fields.provider,
+        authority,
+        binding: fields.binding,
+        mintedAt: fields.mintedAt,
+        workspaceRoot: fields.workspaceRoot,
+        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
+    });
+    const reserved = reserveProjectionDirectory(input);
+    return publishReservedProjection(pact, reserved);
+}
+/**
+ * Mint a repository-authority projection.
+ * Order: validate complete identity → reserve staging → heart + identity + leash → close → atomic rename.
+ */
+export async function mintRepositoryProjection(input) {
+    parseExecutionAuthoritySelection(input.authority, "projection identity", "repository");
+    const fields = parseExecutionPactFields(buildMintPactFields(input));
+    const pact = parseExecutionPact({
+        version: fields.version,
+        pid: fields.pid,
+        akuma: fields.akuma,
+        provider: fields.provider,
+        authority: { kind: "repository" },
+        binding: fields.binding,
+        mintedAt: fields.mintedAt,
+        workspaceRoot: fields.workspaceRoot,
+        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
+    });
+    const reserved = reserveProjectionDirectory(input);
+    return publishReservedProjection(pact, reserved);
+}