project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/context-mutation/mutation-journal-validation-support.js

@@ -0,0 +1,140 @@
+import path from "node:path";
+import { sha256Hex } from "../strict-codec.js";
+export function validateJournalFileState(value, label) {
+    if (!isJournalRecord(value))
+        invalidJournal(`${label}_object_required`);
+    assertExactFields(value, ["exists", "sha256", "bytes_base64", "mode", "identity"], label);
+    if (typeof value.exists !== "boolean")
+        invalidJournal(`${label}_exists_invalid`);
+    if (!value.exists) {
+        if (value.sha256 !== null ||
+            value.bytes_base64 !== null ||
+            value.mode !== null ||
+            value.identity !== null)
+            invalidJournal(`${label}_absent_shape`);
+        return 0;
+    }
+    const digest = validateJournalDigest(value.sha256, `${label}.sha256`);
+    if (typeof value.bytes_base64 !== "string")
+        invalidJournal(`${label}.bytes_base64_string_required`);
+    const bytes = Buffer.from(value.bytes_base64, "base64");
+    if (bytes.toString("base64") !== value.bytes_base64)
+        invalidJournal(`${label}_base64_invalid`);
+    if (sha256Hex(bytes) !== digest)
+        invalidJournal(`${label}_digest_mismatch`);
+    const mode = requiredJournalInteger(value.mode, `${label}.mode`);
+    if (mode > 0o777)
+        invalidJournal(`${label}_mode_invalid`);
+    if (value.identity !== null)
+        validateIdentity(value.identity, label);
+    return bytes.length;
+}
+export function validateJournalRecordedFileState(value, label) {
+    if (!isJournalRecord(value))
+        invalidJournal(`${label}_object_required`);
+    assertExactFields(value, ["exists", "sha256", "mode", "identity"], label);
+    if (typeof value.exists !== "boolean")
+        invalidJournal(`${label}_exists_invalid`);
+    if (!value.exists) {
+        if (value.sha256 !== null || value.mode !== null || value.identity !== null)
+            invalidJournal(`${label}_absent_shape`);
+        return;
+    }
+    validateJournalDigest(value.sha256, `${label}.sha256`);
+    const mode = requiredJournalInteger(value.mode, `${label}.mode`);
+    if (mode > 0o777)
+        invalidJournal(`${label}_mode_invalid`);
+    if (value.identity === null)
+        invalidJournal(`${label}_identity_required`);
+    validateIdentity(value.identity, label);
+}
+export function sameJournalRecordedPayload(recorded, semantic) {
+    if (!isJournalRecord(recorded) || !isJournalRecord(semantic))
+        return false;
+    return (recorded.exists === semantic.exists &&
+        recorded.sha256 === semantic.sha256 &&
+        recorded.mode === semantic.mode);
+}
+export function sameJournalFileState(left, right) {
+    if (!isJournalRecord(left) || !isJournalRecord(right))
+        return false;
+    return (left.exists === right.exists &&
+        left.sha256 === right.sha256 &&
+        left.mode === right.mode);
+}
+export function isPresentJournalState(value) {
+    return isJournalRecord(value) && value.exists === true;
+}
+export function isAbsentJournalState(value) {
+    return isJournalRecord(value) && value.exists === false;
+}
+export function validateJournalTemporaryPath(value, file, transactionId, order) {
+    const temporary = requiredJournalString(value, "file.temporary_path");
+    assertJournalRelative(temporary, "file.temporary_path");
+    const expected = `${path.posix.dirname(file)}/.${path.posix.basename(file)}.ty-context-mutation-${transactionId.slice(0, 16)}-${order}.tmp`;
+    if (temporary !== expected)
+        invalidJournal("temporary_path_unowned");
+}
+export function assertJournalMutationTarget(value) {
+    if (value === "project_context/context.toml")
+        return;
+    assertJournalContextMarkdownPath(value, "mutation_target");
+}
+export function assertJournalContextMarkdownPath(value, label) {
+    assertJournalRelative(value, label);
+    if (!value.startsWith("project_context/") || !value.endsWith(".md"))
+        invalidJournal(`${label}_context_markdown_required`);
+}
+export function assertJournalRelative(value, label) {
+    const normalized = value.replace(/\\/gu, "/");
+    const segments = normalized.split("/");
+    if (value !== normalized ||
+        !normalized ||
+        path.isAbsolute(value) ||
+        normalized.startsWith("/") ||
+        segments.some((segment) => !segment || segment === "." || segment === ".."))
+        invalidJournal(`${label}_unsafe`);
+}
+export function validateJournalDigest(value, label) {
+    const digest = requiredJournalString(value, label);
+    if (!/^[0-9a-f]{64}$/u.test(digest))
+        invalidJournal(`${label}_invalid`);
+    return digest;
+}
+export function requiredJournalString(value, label) {
+    if (typeof value !== "string" || value.length === 0)
+        invalidJournal(`${label}_string_required`);
+    return value;
+}
+export function requiredJournalInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        invalidJournal(`${label}_integer_required`);
+    return value;
+}
+export function isJournalRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function invalidJournal(reason) {
+    throw new Error(`context_mutation_invalid:${reason}`);
+}
+export function validateIdentity(value, label) {
+    if (!isJournalRecord(value))
+        invalidJournal(`${label}_identity_invalid`);
+    const fields = ["dev", "ino", "nlink", "size", "mtime_ns", "ctime_ns"];
+    if (Object.keys(value).sort().join("\0") !== [...fields].sort().join("\0"))
+        invalidJournal(`${label}_identity_fields_invalid`);
+    for (const field of ["dev", "ino", "nlink", "size"]) {
+        const item = value[field];
+        if (typeof item !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(item))
+            invalidJournal(`${label}.identity.${field}_decimal_required`);
+    }
+    for (const field of ["mtime_ns", "ctime_ns"]) {
+        const item = value[field];
+        if (typeof item !== "string" || !/^(?:0|-?[1-9][0-9]*)$/u.test(item))
+            invalidJournal(`${label}.identity.${field}_decimal_required`);
+    }
+}
+function assertExactFields(value, fields, label) {
+    if (Object.keys(value).sort().join("\0") !== [...fields].sort().join("\0"))
+        invalidJournal(`${label}_fields_invalid`);
+}

package/dist/lib/context-mutation/mutation-journal-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ContextMutationJournal } from "./mutation-types.js";
+export declare const CONTEXT_MUTATION_JOURNAL_SCHEMA: "context-mutation-journal-v3";
+export declare function validateContextMutationJournal(value: unknown): ContextMutationJournal;

package/dist/lib/context-mutation/mutation-journal-validation.js

@@ -0,0 +1,177 @@
+import { normalizeContextRole } from "../context-catalog/catalog-portable-contract.js";
+import { validateJournalFiles } from "./mutation-journal-file-validation.js";
+import { assertJournalContextMarkdownPath, assertJournalRelative, invalidJournal, isAbsentJournalState, isJournalRecord, isPresentJournalState, requiredJournalInteger, requiredJournalString, validateJournalDigest, } from "./mutation-journal-validation-support.js";
+export const CONTEXT_MUTATION_JOURNAL_SCHEMA = "context-mutation-journal-v3";
+const LEGACY_CONTEXT_MUTATION_JOURNAL_SCHEMA = "context-mutation-journal-v2";
+const MAX_MUTATION_FILES = 512;
+const MAX_MUTATION_DIRECTORIES = 64;
+const MAX_STORED_BYTES = 64 * 1024 * 1024;
+const MAX_JOURNAL_SEQUENCE = 4095;
+export function validateContextMutationJournal(value) {
+    if (!isJournalRecord(value))
+        invalidJournal("journal_object_required");
+    if (typeof value.schema_version === "string" &&
+        /^context-mutation-journal-v(?:0|1)$/u.test(value.schema_version))
+        invalidJournal("journal_pre_v2_manual_recovery_required:use_the_ty-context_version_that_created_the_journal_or_restore_exact_files_from_version_control");
+    if (value.schema_version !== CONTEXT_MUTATION_JOURNAL_SCHEMA &&
+        value.schema_version !== LEGACY_CONTEXT_MUTATION_JOURNAL_SCHEMA)
+        invalidJournal("journal_schema_unsupported");
+    const transactionId = requiredJournalString(value.transaction_id, "transaction_id");
+    if (!/^[0-9a-f]{64}$/u.test(transactionId))
+        invalidJournal("transaction_id_invalid");
+    const journalSequence = requiredJournalInteger(value.journal_sequence, "journal_sequence");
+    if (journalSequence > MAX_JOURNAL_SEQUENCE)
+        invalidJournal("journal_sequence_exceeded");
+    if (journalSequence === 0) {
+        if (value.previous_journal_sha256 !== null)
+            invalidJournal("initial_journal_predecessor_forbidden");
+    }
+    else {
+        validateJournalDigest(value.previous_journal_sha256, "previous_journal_sha256");
+    }
+    const operation = value.operation;
+    if (operation !== "register" && operation !== "move")
+        invalidJournal("operation_invalid");
+    const state = value.state;
+    if (state !== "planning" &&
+        state !== "prepared" &&
+        state !== "committing" &&
+        state !== "validating")
+        invalidJournal("journal_state_invalid");
+    const files = validateJournalFiles(value.files, transactionId, MAX_MUTATION_FILES, MAX_STORED_BYTES, value.schema_version === CONTEXT_MUTATION_JOURNAL_SCHEMA
+        ? "required-v3"
+        : "forbidden-v2");
+    const directories = validateDirectories(value.directories, operation);
+    validateAppliedPaths(value.applied_paths, files, state);
+    validateJournalDigest(value.catalog_before_identity, "catalog_before_identity");
+    validateJournalDigest(value.catalog_after_identity, "catalog_after_identity");
+    if (!isJournalRecord(value.operation_data))
+        invalidJournal("operation_data_invalid");
+    if (value.operation_data.kind !== operation)
+        invalidJournal("operation_data_kind_mismatch");
+    validateOperationData(value.operation_data, operation);
+    if (operation === "register" &&
+        (files.length !== 1 || files[0].path !== "project_context/context.toml"))
+        invalidJournal("register_file_set_invalid");
+    if (operation === "move")
+        validateMoveFileSet(files, value.operation_data, directories);
+    return value;
+}
+function validateDirectories(value, operation) {
+    if (!Array.isArray(value) || value.length > MAX_MUTATION_DIRECTORIES)
+        invalidJournal("journal_directories_invalid");
+    if (operation === "register" && value.length !== 0)
+        invalidJournal("register_directories_forbidden");
+    const seen = new Set();
+    const directories = [];
+    let previousDepth = 0;
+    for (const entry of value) {
+        if (!isJournalRecord(entry))
+            invalidJournal("journal_directory_object_required");
+        const directory = requiredJournalString(entry.path, "directory.path");
+        assertJournalRelative(directory, "directory.path");
+        if (!directory.startsWith("project_context/"))
+            invalidJournal("journal_directory_context_required");
+        if (entry.before_exists !== false)
+            invalidJournal("journal_directory_before_state_invalid");
+        if (seen.has(directory))
+            invalidJournal("journal_directory_duplicate");
+        seen.add(directory);
+        directories.push(directory);
+        const depth = directory.split("/").length;
+        if (depth < previousDepth)
+            invalidJournal("journal_directory_order_invalid");
+        previousDepth = depth;
+    }
+    return directories;
+}
+function validateMoveFileSet(files, operationData, directories) {
+    if (files.length < 3)
+        invalidJournal("move_file_set_incomplete");
+    const ordered = [...files].sort((left, right) => left.commit_order - right.commit_order);
+    const from = operationData.from_path;
+    const to = operationData.to_path;
+    if (ordered[0].path !== to ||
+        !isAbsentJournalState(ordered[0].before) ||
+        !isPresentJournalState(ordered[0].after))
+        invalidJournal("move_target_change_invalid");
+    const source = ordered.at(-1);
+    if (source.path !== from ||
+        !isPresentJournalState(source.before) ||
+        !isAbsentJournalState(source.after))
+        invalidJournal("move_source_change_invalid");
+    const manifest = ordered.at(-2);
+    if (manifest.path !== "project_context/context.toml" ||
+        !isPresentJournalState(manifest.before) ||
+        !isPresentJournalState(manifest.after))
+        invalidJournal("move_manifest_change_invalid");
+    for (const reference of ordered.slice(1, -2))
+        if (!isPresentJournalState(reference.before) ||
+            !isPresentJournalState(reference.after))
+            invalidJournal("move_reference_change_invalid");
+    for (const directory of directories)
+        if (!to.startsWith(`${directory}/`))
+            invalidJournal("move_directory_not_target_ancestor");
+    for (let index = 1; index < directories.length; index += 1)
+        if (!directories[index].startsWith(`${directories[index - 1]}/`))
+            invalidJournal("move_directories_not_chain");
+}
+function validateAppliedPaths(value, files, state) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))
+        invalidJournal("journal_applied_paths_invalid");
+    const ordered = [...files]
+        .sort((left, right) => left.commit_order - right.commit_order)
+        .map((entry) => entry.path);
+    if (value.some((entry, index) => entry !== ordered[index]) ||
+        new Set(value).size !== value.length)
+        invalidJournal("journal_applied_paths_not_prefix");
+    if ((state === "planning" || state === "prepared") && value.length !== 0)
+        invalidJournal("journal_applied_paths_state_mismatch");
+    if (state === "validating" && value.length !== ordered.length)
+        invalidJournal("journal_applied_paths_state_mismatch");
+    for (const file of files) {
+        const applied = value.includes(file.path);
+        if (applied && file.published_after === null)
+            invalidJournal("journal_applied_path_endpoint_missing");
+        if ((state === "planning" || state === "prepared") &&
+            (file.published_before !== null || file.published_after !== null))
+            invalidJournal("journal_published_state_phase_mismatch");
+    }
+}
+function validateOperationData(value, operation) {
+    const paths = value.expected_default_paths;
+    if (!Array.isArray(paths) || paths.some((entry) => typeof entry !== "string"))
+        invalidJournal("operation_default_paths_invalid");
+    const unique = new Set();
+    for (const file of paths) {
+        assertJournalRelative(file, "default_path");
+        if (unique.has(file))
+            invalidJournal("operation_default_path_duplicate");
+        unique.add(file);
+    }
+    requiredJournalInteger(value.expected_default_bytes, "expected_default_bytes");
+    if (operation === "register") {
+        const contextPath = requiredJournalString(value.context_path, "context_path");
+        assertJournalContextMarkdownPath(contextPath, "context_path");
+        if (typeof value.role !== "string" || !normalizeContextRole(value.role))
+            invalidJournal("operation_role_invalid");
+        if (value.read_policy !== "default" && value.read_policy !== "on-demand")
+            invalidJournal("operation_read_policy_invalid");
+        return;
+    }
+    const from = requiredJournalString(value.from_path, "from_path");
+    const to = requiredJournalString(value.to_path, "to_path");
+    assertJournalContextMarkdownPath(from, "from_path");
+    assertJournalContextMarkdownPath(to, "to_path");
+    if (from === to)
+        invalidJournal("operation_move_same_path");
+    if (value.owner_source !== "area" && value.owner_source !== "context")
+        invalidJournal("operation_owner_source_invalid");
+    if (typeof value.role !== "string" || !normalizeContextRole(value.role))
+        invalidJournal("operation_role_invalid");
+    if (value.read_policy !== null && typeof value.read_policy !== "string")
+        invalidJournal("operation_read_policy_invalid");
+    if (!Array.isArray(value.expected_reference_issues) ||
+        value.expected_reference_issues.some((entry) => typeof entry !== "string"))
+        invalidJournal("operation_reference_issues_invalid");
+}

package/dist/lib/context-mutation/mutation-journal.d.ts

@@ -0,0 +1,8 @@
+export { CONTEXT_MUTATION_JOURNAL_DIRECTORY } from "./mutation-journal-storage.js";
+import type { ContextMutationJournal, ContextMutationJournalState, ContextMutationPlan } from "./mutation-types.js";
+export declare function readContextMutationJournal(repository: string): Promise<ContextMutationJournal | null>;
+export declare function assertNoUnfinishedContextMutationForAuthority(repository: string): Promise<void>;
+export declare function createContextMutationJournal(repository: string, plan: ContextMutationPlan): Promise<ContextMutationJournal>;
+export declare function updateContextMutationJournal(repository: string, expected: ContextMutationJournal, successor: ContextMutationJournal, expectedStates: ContextMutationJournalState[]): Promise<ContextMutationJournal>;
+export declare function removeContextMutationJournal(repository: string, expected: ContextMutationJournal): Promise<void>;
+export declare function assertSameContextMutationJournalSnapshot(expected: ContextMutationJournal, current: ContextMutationJournal): void;

package/dist/lib/context-mutation/mutation-journal.js

@@ -0,0 +1,111 @@
+import { canonicalJson, sha256Hex } from "../strict-codec.js";
+import { publishInitialJournalSnapshot, publishNextJournalSnapshot, readLatestJournalSnapshot, removeJournalSnapshotChain, assertExpectedJournalSnapshot, } from "./mutation-journal-storage.js";
+export { CONTEXT_MUTATION_JOURNAL_DIRECTORY } from "./mutation-journal-storage.js";
+import { CONTEXT_MUTATION_JOURNAL_SCHEMA, validateContextMutationJournal, } from "./mutation-journal-validation.js";
+const journalSnapshotBindings = new WeakMap();
+export async function readContextMutationJournal(repository) {
+    const snapshot = await readLatestJournalSnapshot(repository);
+    return snapshot ? bindJournalSnapshot(snapshot) : null;
+}
+export async function assertNoUnfinishedContextMutationForAuthority(repository) {
+    const journal = await readContextMutationJournal(repository);
+    if (journal)
+        throw new Error(`active_authority_context_mutation_unfinished:${journal.transaction_id}`);
+}
+export async function createContextMutationJournal(repository, plan) {
+    const journal = {
+        schema_version: CONTEXT_MUTATION_JOURNAL_SCHEMA,
+        ...plan,
+        journal_sequence: 0,
+        previous_journal_sha256: null,
+        state: "planning",
+        applied_paths: [],
+    };
+    validateContextMutationJournal(journal);
+    return bindJournalSnapshot(await publishInitialJournalSnapshot(repository, journal));
+}
+export async function updateContextMutationJournal(repository, expected, successor, expectedStates) {
+    validateContextMutationJournal(expected);
+    validateContextMutationJournal(successor);
+    if (canonicalJson(immutableMutationPlan(expected)) !==
+        canonicalJson(immutableMutationPlan(successor)))
+        invalid("journal_successor_plan_changed");
+    const current = await readLatestJournalSnapshot(repository);
+    if (!current)
+        invalid("journal_missing");
+    try {
+        assertExpectedJournalSnapshot(current, requiredSnapshotBinding(expected));
+    }
+    catch (error) {
+        if (/journal_compare_and_swap_failed$/u.test(message(error)))
+            invalid("journal_predecessor_compare_and_swap_failed");
+        throw error;
+    }
+    if (current.journal.transaction_id !== expected.transaction_id)
+        invalid("journal_transaction_changed");
+    const expectedBytes = Buffer.from(canonicalJson(expected), "utf8");
+    if (current.journal.journal_sequence !== expected.journal_sequence ||
+        sha256Hex(current.bytes) !== sha256Hex(expectedBytes))
+        invalid("journal_predecessor_compare_and_swap_failed");
+    if (!expectedStates.includes(current.journal.state))
+        invalid(`journal_state_changed:${current.journal.state}`);
+    const next = {
+        ...successor,
+        journal_sequence: expected.journal_sequence + 1,
+        previous_journal_sha256: sha256Hex(current.bytes),
+    };
+    validateContextMutationJournal(next);
+    return bindJournalSnapshot(await publishNextJournalSnapshot(repository, next, current));
+}
+function immutableMutationPlan(journal) {
+    return {
+        transaction_id: journal.transaction_id,
+        operation: journal.operation,
+        catalog_before_identity: journal.catalog_before_identity,
+        catalog_after_identity: journal.catalog_after_identity,
+        directories: journal.directories,
+        files: journal.files.map((file) => ({
+            path: file.path,
+            physical_path: file.physical_path,
+            before: file.before,
+            after: file.after,
+            commit_order: file.commit_order,
+            temporary_path: file.temporary_path,
+        })),
+        operation_data: journal.operation_data,
+    };
+}
+export async function removeContextMutationJournal(repository, expected) {
+    validateContextMutationJournal(expected);
+    const current = await readLatestJournalSnapshot(repository);
+    if (!current)
+        invalid("journal_missing");
+    const expectedSnapshot = requiredSnapshotBinding(expected);
+    assertExpectedJournalSnapshot(current, expectedSnapshot);
+    if (current.journal.journal_sequence !== expected.journal_sequence ||
+        sha256Hex(current.bytes) !==
+            sha256Hex(Buffer.from(canonicalJson(expected), "utf8")))
+        invalid("journal_terminal_compare_and_swap_failed");
+    await removeJournalSnapshotChain(repository, current);
+}
+export function assertSameContextMutationJournalSnapshot(expected, current) {
+    const expectedSnapshot = requiredSnapshotBinding(expected);
+    const currentSnapshot = requiredSnapshotBinding(current);
+    assertExpectedJournalSnapshot(currentSnapshot, expectedSnapshot);
+}
+function bindJournalSnapshot(snapshot) {
+    journalSnapshotBindings.set(snapshot.journal, snapshot);
+    return snapshot.journal;
+}
+function requiredSnapshotBinding(journal) {
+    const snapshot = journalSnapshotBindings.get(journal);
+    if (!snapshot)
+        invalid("journal_predecessor_identity_missing");
+    return snapshot;
+}
+function invalid(reason) {
+    throw new Error(`context_mutation_invalid:${reason}`);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/context-mutation/mutation-live-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ContextMutationJournal } from "./mutation-types.js";
+export declare function validateLiveContextMutation(repository: string, journal: ContextMutationJournal): Promise<void>;
+export declare function validateRolledBackContextMutation(repository: string, journal: ContextMutationJournal): Promise<void>;

package/dist/lib/context-mutation/mutation-live-validation.js

@@ -0,0 +1,51 @@
+import { readFile } from "node:fs/promises";
+import { loadContextCatalog } from "../context-catalog/catalog-load.js";
+import { catalogErrors } from "../context-catalog/catalog-diagnostics.js";
+import { resolveCatalogFile } from "../context-catalog/catalog-paths.js";
+import { assertProtectedRepositoryFile } from "../repository-path-safety.js";
+import { validateContextContentForRole } from "../validators.js";
+import { validateLiveContextMove } from "../context-move/context-move-live-validation.js";
+import { contextCatalogIdentity, contextFootprintState, } from "./mutation-staged-fs.js";
+export async function validateLiveContextMutation(repository, journal) {
+    const catalog = await loadContextCatalog(repository);
+    const errors = catalogErrors(catalog.diagnostics);
+    if (errors.length)
+        invalid(`live_catalog:${errors.join("|")}`);
+    if (contextCatalogIdentity(catalog) !== journal.catalog_after_identity)
+        invalid("live_catalog_identity_mismatch");
+    const footprint = contextFootprintState(catalog);
+    if (footprint.bytes !== journal.operation_data.expected_default_bytes ||
+        !sameArray(footprint.paths, journal.operation_data.expected_default_paths))
+        invalid("live_default_footprint_mismatch");
+    if (journal.operation_data.kind === "register") {
+        const data = journal.operation_data;
+        const registered = catalog.registered_contexts.filter((entry) => entry.path === data.context_path && entry.source === "context");
+        if (registered.length !== 1)
+            invalid("live_registration_missing");
+        if (registered[0].role !== data.role ||
+            registered[0].read_policy !== data.read_policy)
+            invalid("live_registration_metadata_mismatch");
+        const file = resolveCatalogFile(catalog, data.context_path);
+        if (!file)
+            invalid("live_registration_file_missing");
+        const absolute = await assertProtectedRepositoryFile(repository, file.absolute_path, "context_mutation_registered_context");
+        const content = await readFile(absolute, "utf8");
+        const recoveryErrors = validateContextContentForRole(repository, data.context_path, content, data.role);
+        if (recoveryErrors.length)
+            invalid(`live_context_recovery:${recoveryErrors.join("|")}`);
+        return;
+    }
+    await validateLiveContextMove(repository, catalog, journal);
+}
+export async function validateRolledBackContextMutation(repository, journal) {
+    const catalog = await loadContextCatalog(repository);
+    if (contextCatalogIdentity(catalog) !== journal.catalog_before_identity)
+        invalid("rollback_catalog_identity_mismatch");
+}
+function sameArray(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+function invalid(reason) {
+    throw new Error(`context_mutation_invalid:${reason}`);
+}

package/dist/lib/context-mutation/mutation-recovery.d.ts

@@ -0,0 +1,4 @@
+import type { ContextMutationStatus } from "./mutation-types.js";
+export declare function contextMutationStatus(repository: string): Promise<ContextMutationStatus>;
+export declare function completeContextMutation(repository: string): Promise<ContextMutationStatus>;
+export declare function rollbackContextMutation(repository: string): Promise<ContextMutationStatus>;