semantifold 0.9.0 → 0.10.0

package/build/src/project-reporter.js

@@ -0,0 +1,293 @@
+// @ts-check
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+/**
+ * Emits concise human output or the deterministic Task-039 NDJSON state protocol.
+ */
+export class ProjectBuildReporter {
+    /** @type {"human" | "ndjson"} */
+    #format;
+    /** @type {WritableOutput} */
+    #stdout;
+    /** @type {WritableOutput} */
+    #stderr;
+    /** @type {string | null} */
+    #projectId = null;
+    /** @type {string | null} */
+    #snapshotHash = null;
+    #terminal = false;
+    /**
+     * Creates a one-cycle reporter.
+     * @param {{format?: "human" | "ndjson", stderr?: WritableOutput, stdout?: WritableOutput}} [options] - Output mode and sinks.
+     */
+    constructor(options = {}) {
+        const format = options.format ?? "human";
+        if (format != "human" && format != "ndjson")
+            throw new TypeError("Invalid project build reporter format.");
+        this.#format = format;
+        this.#stdout = options.stdout ?? process.stdout;
+        this.#stderr = options.stderr ?? process.stderr;
+        if (typeof this.#stdout?.write != "function" || typeof this.#stderr?.write != "function") {
+            throw new TypeError("Project build reporter requires writable output sinks.");
+        }
+    }
+    /**
+     * Reports validated project configuration.
+     * @param {string} projectId - Stable project identity.
+     * @returns {void}
+     */
+    projectLoaded(projectId) {
+        this.#projectId = projectId;
+        this.#emitState({ state: "project-loaded" });
+    }
+    /**
+     * Reports one stable complete source snapshot.
+     * @param {string} snapshotHash - Complete ordered snapshot hash.
+     * @returns {void}
+     */
+    snapshotLoaded(snapshotHash) {
+        this.#snapshotHash = snapshotHash;
+        this.#emitState({ snapshotHash, state: "snapshot-loaded" });
+    }
+    /**
+     * Reports one ordered generated target.
+     * @param {import("./project-build.js").ProjectBuildTargetResult} target - Completed target result.
+     * @returns {void}
+     */
+    targetGenerated(target) {
+        this.#emitState({
+            artifactCount: target.artifactCount,
+            language: target.language,
+            role: target.role,
+            state: "target-generated",
+            target: target.id
+        });
+    }
+    /**
+     * Reports one successful target-check stage with exact process evidence.
+     * @param {{id: string, language: string, stage: import("./semantic/types.js").TargetCheckStageResult}} checked - Target and stage result.
+     * @returns {void}
+     */
+    targetChecked(checked) {
+        this.#emitState({
+            argv: checked.stage.argv,
+            durationMs: checked.stage.durationMs,
+            exitCode: checked.stage.exitCode,
+            language: checked.language,
+            signal: checked.stage.signal,
+            stage: checked.stage.stage,
+            state: "target-checked",
+            stderr: checked.stage.stderr,
+            stdout: checked.stage.stdout,
+            target: checked.id,
+            tool: checked.stage.tool
+        });
+    }
+    /**
+     * Emits the sole successful terminal record.
+     * @param {import("./project-build.js").ProjectBuildSuccess} result - Committed build result.
+     * @returns {void}
+     */
+    succeeded(result) {
+        this.#requireOpenTerminal();
+        this.#terminal = true;
+        this.#projectId = result.projectId;
+        this.#snapshotHash = result.snapshotHash;
+        if (this.#format == "human") {
+            const targetWord = result.targets.length == 1 ? "target" : "targets";
+            const action = result.checked ? "Built and checked" : "Built";
+            this.#stdout.write(`${action} project '${result.projectId}' as generation '${result.generationId}' with ${result.targets.length} ${targetWord}.\n`);
+            return;
+        }
+        this.#writeNdjson({
+            exitCode: 0,
+            checked: result.checked,
+            generationId: result.generationId,
+            snapshotHash: result.snapshotHash,
+            state: "succeeded",
+            targets: result.targets.map(target => ({
+                artifactCount: target.artifactCount,
+                id: target.id,
+                language: target.language,
+                role: target.role
+            })),
+            terminal: true
+        });
+    }
+    /**
+     * Emits the sole failed terminal record while preserving the first diagnostic.
+     * @param {unknown} failure - Build or CLI failure.
+     * @returns {void}
+     */
+    failed(failure) {
+        this.#requireOpenTerminal();
+        this.#terminal = true;
+        const diagnostic = normalizeDiagnostic(failure);
+        if (this.#format == "human") {
+            this.#stderr.write(formatHumanProjectFailure(diagnostic, "Build failed"));
+            return;
+        }
+        this.#writeNdjson({
+            diagnostic: diagnosticRecord(diagnostic),
+            exitCode: 1,
+            ...(this.#snapshotHash === null ? {} : { snapshotHash: this.#snapshotHash }),
+            state: "failed",
+            terminal: true
+        });
+    }
+    /**
+     * Emits a non-terminal machine state when selected.
+     * @param {Record<string, unknown>} fields - State-specific fields.
+     * @returns {void}
+     */
+    #emitState(fields) {
+        if (this.#format == "ndjson")
+            this.#writeNdjson(fields);
+    }
+    /**
+     * Writes one complete NDJSON protocol record.
+     * @param {Record<string, unknown>} fields - State-specific fields.
+     * @returns {void}
+     */
+    #writeNdjson(fields) {
+        this.#stdout.write(`${JSON.stringify({
+            cycle: 1,
+            project: this.#projectId,
+            schema: "SemantifoldBuildEvent",
+            version: 1,
+            ...fields
+        })}\n`);
+    }
+    /**
+     * Rejects an attempt to emit more than one terminal record.
+     * @returns {void}
+     */
+    #requireOpenTerminal() {
+        if (this.#terminal)
+            throw new TypeError("Project build reporter already emitted its terminal record.");
+    }
+}
+/**
+ * Normalizes an unexpected failure without replacing a Semantifold diagnostic.
+ * @param {unknown} failure - Opaque failure.
+ * @returns {SemantifoldDiagnostic} Stable diagnostic.
+ */
+export function normalizeDiagnostic(failure) {
+    if (failure instanceof SemantifoldDiagnostic)
+        return failure;
+    const cause = failure instanceof Error ? failure : new Error(String(failure));
+    return new SemantifoldDiagnostic({
+        cause,
+        code: "PROJECT_BUILD_FAILED",
+        language: "project",
+        message: "Project build failed unexpectedly."
+    });
+}
+/**
+ * Serializes stable public diagnostic fields without causes or host paths.
+ * @param {SemantifoldDiagnostic} diagnostic - Normalized diagnostic.
+ * @returns {Record<string, unknown>} Protocol diagnostic.
+ */
+export function diagnosticRecord(diagnostic) {
+    return {
+        code: diagnostic.code,
+        detail: diagnostic.detail,
+        language: diagnostic.language,
+        ...(diagnostic.location === undefined ? {} : { location: diagnostic.location }),
+        ...optionalDiagnosticFields(diagnostic),
+        ...(diagnostic.cause instanceof SemantifoldDiagnostic ? { cause: diagnosticRecord(diagnostic.cause) } : {})
+    };
+}
+/**
+ * Retains stable structured process and target context.
+ * @param {SemantifoldDiagnostic} diagnostic - Diagnostic to serialize.
+ * @returns {Record<string, unknown>} Present optional fields.
+ */
+function optionalDiagnosticFields(diagnostic) {
+    const fields = [
+        "command", "durationMs", "executable", "exitCode", "projectId", "signal", "stage", "stderr", "stdout", "targetId",
+        "toolId", "version"
+    ];
+    /** @type {Record<string, unknown>} */
+    const result = {};
+    for (const field of fields) {
+        const value = Reflect.get(diagnostic, field);
+        if (value !== undefined)
+            result[field] = value;
+    }
+    return result;
+}
+/**
+ * Finds the most specific Semantifold diagnostic in a preserved cause chain.
+ * @param {SemantifoldDiagnostic} diagnostic - Root diagnostic.
+ * @returns {SemantifoldDiagnostic} Deepest structured diagnostic.
+ */
+function deepestDiagnostic(diagnostic) {
+    let current = diagnostic;
+    while (current.cause instanceof SemantifoldDiagnostic)
+        current = current.cause;
+    return current;
+}
+/**
+ * Formats nested structured diagnostics without duplicating detailed checker-process evidence.
+ * @param {SemantifoldDiagnostic} diagnostic - Root diagnostic.
+ * @param {SemantifoldDiagnostic} deepest - Deepest structured diagnostic.
+ * @returns {string} Ordered human-readable cause lines.
+ */
+function humanDiagnosticCauses(diagnostic, deepest) {
+    let current = diagnostic.cause;
+    let result = "";
+    while (current instanceof SemantifoldDiagnostic) {
+        if (current !== deepest || !current.code.startsWith("TARGET_CHECK_")) {
+            result += `Caused by: ${current.message}\n`;
+        }
+        current = current.cause;
+    }
+    return result;
+}
+/**
+ * Formats complete bounded check-process evidence without flattening its diagnostic.
+ * @param {SemantifoldDiagnostic} diagnostic - Deepest structured diagnostic.
+ * @returns {string} Human-readable check context and streams, when applicable.
+ */
+function humanProcessEvidence(diagnostic) {
+    if (!diagnostic.code.startsWith("TARGET_CHECK_"))
+        return "";
+    /**
+     * Reads one optional diagnostic field for compact human display.
+     * @param {string} field - Field identity.
+     * @returns {unknown} Present value or an explicit absence marker.
+     */
+    const value = field => Reflect.get(diagnostic, field) ?? "none";
+    const heading = `Check failure: project='${value("projectId")}' target='${value("targetId")}' ` +
+        `language='${diagnostic.language}' tool='${value("toolId")}' executable='${value("executable")}' ` +
+        `version='${value("version")}' stage='${value("stage")}' exitCode=${value("exitCode")} ` +
+        `signal=${value("signal")} durationMs=${value("durationMs")}\n`;
+    return `${heading}${humanStream("stdout", diagnostic.stdout)}${humanStream("stderr", diagnostic.stderr)}`;
+}
+/**
+ * Formats one normalized failure with preserved nested process evidence.
+ * This helper is shared by the one-shot and watch reporters but is not a package-root API.
+ * @param {unknown} failure - Opaque or normalized failure.
+ * @param {string} heading - Human output heading without punctuation.
+ * @returns {string} Complete newline-terminated failure text.
+ */
+export function formatHumanProjectFailure(failure, heading) {
+    const diagnostic = normalizeDiagnostic(failure);
+    const processFailure = deepestDiagnostic(diagnostic);
+    const causes = humanDiagnosticCauses(diagnostic, processFailure);
+    const evidence = humanProcessEvidence(processFailure);
+    return `${heading}: ${diagnostic.message}\n${causes}${evidence}`;
+}
+/**
+ * Labels one bounded process stream and preserves its exact content.
+ * @param {string} name - Stream identity.
+ * @param {unknown} content - Captured stream value.
+ * @returns {string} Labeled newline-terminated stream evidence.
+ */
+function humanStream(name, content) {
+    if (typeof content != "string" || content.length == 0)
+        return `${name}:\n<empty>\n`;
+    return `${name}:\n${content}${content.endsWith("\n") ? "" : "\n"}`;
+}
+/** @typedef {{write: (chunk: string) => unknown}} WritableOutput */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-reporter.js","sourceRoot":"","sources":["../../src/project-reporter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\n\n/**\n * Emits concise human output or the deterministic Task-039 NDJSON state protocol.\n */\nexport class ProjectBuildReporter {\n  /** @type {\"human\" | \"ndjson\"} */\n  #format\n  /** @type {WritableOutput} */\n  #stdout\n  /** @type {WritableOutput} */\n  #stderr\n  /** @type {string | null} */\n  #projectId = null\n  /** @type {string | null} */\n  #snapshotHash = null\n  #terminal = false\n\n  /**\n   * Creates a one-cycle reporter.\n   * @param {{format?: \"human\" | \"ndjson\", stderr?: WritableOutput, stdout?: WritableOutput}} [options] - Output mode and sinks.\n   */\n  constructor(options = {}) {\n    const format = options.format ?? \"human\"\n\n    if (format != \"human\" && format != \"ndjson\") throw new TypeError(\"Invalid project build reporter format.\")\n    this.#format = format\n    this.#stdout = options.stdout ?? process.stdout\n    this.#stderr = options.stderr ?? process.stderr\n    if (typeof this.#stdout?.write != \"function\" || typeof this.#stderr?.write != \"function\") {\n      throw new TypeError(\"Project build reporter requires writable output sinks.\")\n    }\n  }\n\n  /**\n   * Reports validated project configuration.\n   * @param {string} projectId - Stable project identity.\n   * @returns {void}\n   */\n  projectLoaded(projectId) {\n    this.#projectId = projectId\n    this.#emitState({state: \"project-loaded\"})\n  }\n\n  /**\n   * Reports one stable complete source snapshot.\n   * @param {string} snapshotHash - Complete ordered snapshot hash.\n   * @returns {void}\n   */\n  snapshotLoaded(snapshotHash) {\n    this.#snapshotHash = snapshotHash\n    this.#emitState({snapshotHash, state: \"snapshot-loaded\"})\n  }\n\n  /**\n   * Reports one ordered generated target.\n   * @param {import(\"./project-build.js\").ProjectBuildTargetResult} target - Completed target result.\n   * @returns {void}\n   */\n  targetGenerated(target) {\n    this.#emitState({\n      artifactCount: target.artifactCount,\n      language: target.language,\n      role: target.role,\n      state: \"target-generated\",\n      target: target.id\n    })\n  }\n\n  /**\n   * Reports one successful target-check stage with exact process evidence.\n   * @param {{id: string, language: string, stage: import(\"./semantic/types.js\").TargetCheckStageResult}} checked - Target and stage result.\n   * @returns {void}\n   */\n  targetChecked(checked) {\n    this.#emitState({\n      argv: checked.stage.argv,\n      durationMs: checked.stage.durationMs,\n      exitCode: checked.stage.exitCode,\n      language: checked.language,\n      signal: checked.stage.signal,\n      stage: checked.stage.stage,\n      state: \"target-checked\",\n      stderr: checked.stage.stderr,\n      stdout: checked.stage.stdout,\n      target: checked.id,\n      tool: checked.stage.tool\n    })\n  }\n\n  /**\n   * Emits the sole successful terminal record.\n   * @param {import(\"./project-build.js\").ProjectBuildSuccess} result - Committed build result.\n   * @returns {void}\n   */\n  succeeded(result) {\n    this.#requireOpenTerminal()\n    this.#terminal = true\n    this.#projectId = result.projectId\n    this.#snapshotHash = result.snapshotHash\n    if (this.#format == \"human\") {\n      const targetWord = result.targets.length == 1 ? \"target\" : \"targets\"\n\n      const action = result.checked ? \"Built and checked\" : \"Built\"\n\n      this.#stdout.write(`${action} project '${result.projectId}' as generation '${result.generationId}' with ${result.targets.length} ${targetWord}.\\n`)\n      return\n    }\n    this.#writeNdjson({\n      exitCode: 0,\n      checked: result.checked,\n      generationId: result.generationId,\n      snapshotHash: result.snapshotHash,\n      state: \"succeeded\",\n      targets: result.targets.map(target => ({\n        artifactCount: target.artifactCount,\n        id: target.id,\n        language: target.language,\n        role: target.role\n      })),\n      terminal: true\n    })\n  }\n\n  /**\n   * Emits the sole failed terminal record while preserving the first diagnostic.\n   * @param {unknown} failure - Build or CLI failure.\n   * @returns {void}\n   */\n  failed(failure) {\n    this.#requireOpenTerminal()\n    this.#terminal = true\n    const diagnostic = normalizeDiagnostic(failure)\n\n    if (this.#format == \"human\") {\n      this.#stderr.write(formatHumanProjectFailure(diagnostic, \"Build failed\"))\n      return\n    }\n    this.#writeNdjson({\n      diagnostic: diagnosticRecord(diagnostic),\n      exitCode: 1,\n      ...(this.#snapshotHash === null ? {} : {snapshotHash: this.#snapshotHash}),\n      state: \"failed\",\n      terminal: true\n    })\n  }\n\n  /**\n   * Emits a non-terminal machine state when selected.\n   * @param {Record<string, unknown>} fields - State-specific fields.\n   * @returns {void}\n   */\n  #emitState(fields) {\n    if (this.#format == \"ndjson\") this.#writeNdjson(fields)\n  }\n\n  /**\n   * Writes one complete NDJSON protocol record.\n   * @param {Record<string, unknown>} fields - State-specific fields.\n   * @returns {void}\n   */\n  #writeNdjson(fields) {\n    this.#stdout.write(`${JSON.stringify({\n      cycle: 1,\n      project: this.#projectId,\n      schema: \"SemantifoldBuildEvent\",\n      version: 1,\n      ...fields\n    })}\\n`)\n  }\n\n  /**\n   * Rejects an attempt to emit more than one terminal record.\n   * @returns {void}\n   */\n  #requireOpenTerminal() {\n    if (this.#terminal) throw new TypeError(\"Project build reporter already emitted its terminal record.\")\n  }\n}\n\n/**\n * Normalizes an unexpected failure without replacing a Semantifold diagnostic.\n * @param {unknown} failure - Opaque failure.\n * @returns {SemantifoldDiagnostic} Stable diagnostic.\n */\nexport function normalizeDiagnostic(failure) {\n  if (failure instanceof SemantifoldDiagnostic) return failure\n  const cause = failure instanceof Error ? failure : new Error(String(failure))\n\n  return new SemantifoldDiagnostic({\n    cause,\n    code: \"PROJECT_BUILD_FAILED\",\n    language: \"project\",\n    message: \"Project build failed unexpectedly.\"\n  })\n}\n\n/**\n * Serializes stable public diagnostic fields without causes or host paths.\n * @param {SemantifoldDiagnostic} diagnostic - Normalized diagnostic.\n * @returns {Record<string, unknown>} Protocol diagnostic.\n */\nexport function diagnosticRecord(diagnostic) {\n  return {\n    code: diagnostic.code,\n    detail: diagnostic.detail,\n    language: diagnostic.language,\n    ...(diagnostic.location === undefined ? {} : {location: diagnostic.location}),\n    ...optionalDiagnosticFields(diagnostic),\n    ...(diagnostic.cause instanceof SemantifoldDiagnostic ? {cause: diagnosticRecord(diagnostic.cause)} : {})\n  }\n}\n\n/**\n * Retains stable structured process and target context.\n * @param {SemantifoldDiagnostic} diagnostic - Diagnostic to serialize.\n * @returns {Record<string, unknown>} Present optional fields.\n */\nfunction optionalDiagnosticFields(diagnostic) {\n  const fields = [\n    \"command\", \"durationMs\", \"executable\", \"exitCode\", \"projectId\", \"signal\", \"stage\", \"stderr\", \"stdout\", \"targetId\",\n    \"toolId\", \"version\"\n  ]\n  /** @type {Record<string, unknown>} */\n  const result = {}\n\n  for (const field of fields) {\n    const value = Reflect.get(diagnostic, field)\n\n    if (value !== undefined) result[field] = value\n  }\n\n  return result\n}\n\n/**\n * Finds the most specific Semantifold diagnostic in a preserved cause chain.\n * @param {SemantifoldDiagnostic} diagnostic - Root diagnostic.\n * @returns {SemantifoldDiagnostic} Deepest structured diagnostic.\n */\nfunction deepestDiagnostic(diagnostic) {\n  let current = diagnostic\n\n  while (current.cause instanceof SemantifoldDiagnostic) current = current.cause\n\n  return current\n}\n\n/**\n * Formats nested structured diagnostics without duplicating detailed checker-process evidence.\n * @param {SemantifoldDiagnostic} diagnostic - Root diagnostic.\n * @param {SemantifoldDiagnostic} deepest - Deepest structured diagnostic.\n * @returns {string} Ordered human-readable cause lines.\n */\nfunction humanDiagnosticCauses(diagnostic, deepest) {\n  let current = diagnostic.cause\n  let result = \"\"\n\n  while (current instanceof SemantifoldDiagnostic) {\n    if (current !== deepest || !current.code.startsWith(\"TARGET_CHECK_\")) {\n      result += `Caused by: ${current.message}\\n`\n    }\n    current = current.cause\n  }\n\n  return result\n}\n\n/**\n * Formats complete bounded check-process evidence without flattening its diagnostic.\n * @param {SemantifoldDiagnostic} diagnostic - Deepest structured diagnostic.\n * @returns {string} Human-readable check context and streams, when applicable.\n */\nfunction humanProcessEvidence(diagnostic) {\n  if (!diagnostic.code.startsWith(\"TARGET_CHECK_\")) return \"\"\n  /**\n   * Reads one optional diagnostic field for compact human display.\n   * @param {string} field - Field identity.\n   * @returns {unknown} Present value or an explicit absence marker.\n   */\n  const value = field => Reflect.get(diagnostic, field) ?? \"none\"\n  const heading = `Check failure: project='${value(\"projectId\")}' target='${value(\"targetId\")}' ` +\n    `language='${diagnostic.language}' tool='${value(\"toolId\")}' executable='${value(\"executable\")}' ` +\n    `version='${value(\"version\")}' stage='${value(\"stage\")}' exitCode=${value(\"exitCode\")} ` +\n    `signal=${value(\"signal\")} durationMs=${value(\"durationMs\")}\\n`\n\n  return `${heading}${humanStream(\"stdout\", diagnostic.stdout)}${humanStream(\"stderr\", diagnostic.stderr)}`\n}\n\n/**\n * Formats one normalized failure with preserved nested process evidence.\n * This helper is shared by the one-shot and watch reporters but is not a package-root API.\n * @param {unknown} failure - Opaque or normalized failure.\n * @param {string} heading - Human output heading without punctuation.\n * @returns {string} Complete newline-terminated failure text.\n */\nexport function formatHumanProjectFailure(failure, heading) {\n  const diagnostic = normalizeDiagnostic(failure)\n  const processFailure = deepestDiagnostic(diagnostic)\n  const causes = humanDiagnosticCauses(diagnostic, processFailure)\n  const evidence = humanProcessEvidence(processFailure)\n\n  return `${heading}: ${diagnostic.message}\\n${causes}${evidence}`\n}\n\n/**\n * Labels one bounded process stream and preserves its exact content.\n * @param {string} name - Stream identity.\n * @param {unknown} content - Captured stream value.\n * @returns {string} Labeled newline-terminated stream evidence.\n */\nfunction humanStream(name, content) {\n  if (typeof content != \"string\" || content.length == 0) return `${name}:\\n<empty>\\n`\n\n  return `${name}:\\n${content}${content.endsWith(\"\\n\") ? \"\" : \"\\n\"}`\n}\n\n/** @typedef {{write: (chunk: string) => unknown}} WritableOutput */\n"]}

package/build/src/project-snapshot.d.ts

@@ -0,0 +1,129 @@
+import { SemantifoldProject } from "./project-manifest.js";
+/**
+ * Installs an internal deterministic read observer for real-filesystem snapshot specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectSnapshotBuilder} builder - Snapshot builder instance.
+ * @param {(event: Readonly<{attempt: number, pass: number, path: string}>) => Promise<void> | void} observer - Ordered read observer.
+ * @returns {void}
+ */
+export declare function observeProjectSnapshotReads(builder: ProjectSnapshotBuilder, observer: (event: Readonly<{
+    attempt: number;
+    pass: number;
+    path: string;
+}>) => Promise<void> | void): void;
+/**
+ * One complete immutable ordered source snapshot.
+ */
+export declare class ProjectSnapshot {
+    hash: string;
+    manifestText: string;
+    projectId: string;
+    sources: readonly Readonly<{
+        id: string;
+        language: import("./semantic/types.js").SemanticLanguage;
+        path: string;
+        source: string;
+    }>[];
+    /**
+     * Constructs a trusted snapshot value.
+     * @param {{hash: string, manifestText: string, projectId: string, sources: SnapshotSource[]}} value - Stable snapshot fields.
+     */
+    constructor(value: {
+        hash: string;
+        manifestText: string;
+        projectId: string;
+        sources: SnapshotSource[];
+    });
+}
+/**
+ * Reads one complete graph twice before exposing an immutable source snapshot.
+ */
+export declare class ProjectSnapshotBuilder {
+    /**
+     * Builds a stable snapshot with one bounded retry when the graph changes mid-read.
+     * @param {SemantifoldProject} project - Validated immutable project.
+     * @returns {Promise<ProjectSnapshot>} Stable complete snapshot.
+     */
+    build(project: SemantifoldProject): Promise<ProjectSnapshot>;
+}
+export type SnapshotSource = {
+    /**
+     * - Stable semantic module identity.
+     */
+    id: string;
+    /**
+     * - Registered source language.
+     */
+    language: import("./semantic/types.js").SemanticLanguage;
+    /**
+     * - Project-relative source path.
+     */
+    path: string;
+    /**
+     * - Exact decoded source text.
+     */
+    source: string;
+};
+export type ProjectGraphRead = {
+    /**
+     * - Exact manifest bytes.
+     */
+    manifestBytes: Buffer;
+    /**
+     * - Stable manifest device/inode identity.
+     */
+    manifestIdentity: string;
+    /**
+     * - Stable manifest mutation-sensitive state.
+     */
+    manifestState: string;
+    /**
+     * - Exact source bytes in manifest order.
+     */
+    sourceBytes: Buffer[];
+    /**
+     * - Stable source device/inode identities in manifest order.
+     */
+    sourceIdentities: string[];
+    /**
+     * - Stable source mutation-sensitive states in manifest order.
+     */
+    sourceStates: string[];
+};
+export type StableFileRead = {
+    /**
+     * - Exact stable file bytes.
+     */
+    bytes: Buffer;
+    /**
+     * - Stable device/inode identity.
+     */
+    identity: string;
+    /**
+     * - Stable mutation-sensitive file state.
+     */
+    state: string;
+};
+/**
+ * @typedef SnapshotSource
+ * @property {string} id - Stable semantic module identity.
+ * @property {import("./semantic/types.js").SemanticLanguage} language - Registered source language.
+ * @property {string} path - Project-relative source path.
+ * @property {string} source - Exact decoded source text.
+ */
+/**
+ * @typedef ProjectGraphRead
+ * @property {Buffer} manifestBytes - Exact manifest bytes.
+ * @property {string} manifestIdentity - Stable manifest device/inode identity.
+ * @property {string} manifestState - Stable manifest mutation-sensitive state.
+ * @property {Buffer[]} sourceBytes - Exact source bytes in manifest order.
+ * @property {string[]} sourceIdentities - Stable source device/inode identities in manifest order.
+ * @property {string[]} sourceStates - Stable source mutation-sensitive states in manifest order.
+ */
+/**
+ * @typedef StableFileRead
+ * @property {Buffer} bytes - Exact stable file bytes.
+ * @property {string} identity - Stable device/inode identity.
+ * @property {string} state - Stable mutation-sensitive file state.
+ */
+//# sourceMappingURL=project-snapshot.d.ts.map

package/build/src/project-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-snapshot.d.ts","sourceRoot":"","sources":["../../src/project-snapshot.js"],"names":[],"mappings":"AAMA,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAA;AAMxD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAJxC,sBAIwC,EAAE,QAAQ,EAHlD,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAGlC,GAFhD,IAAI,CAOhB;AAED;;GAEG;AACH,qBAAa,eAAe;IAMnB,IAAI;IACJ,YAAY;IACZ,SAAS;IACT,OAAO;YAuVF,MAAM;kBACN,OAAO,qBAAqB,EAAE,gBAAgB;cAC9C,MAAM;gBACN,MAAM;;IAlWlB;;;OAGG;IACH,YAAY,KAAK,EAFN;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,EAAE,CAAA;KAE3E,EAMhB;CACF;AAED;;GAEG;AACH,qBAAa,sBAAsB;IACjC;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAHR,kBAGQ,GAFN,OAAO,CAAC,eAAe,CAAC,CAmDpC;CACF;AAsRE,YAAS,cAAc,GACvB;;;;IAAmB,EAAE,EAAV,MAAM,CACjB;;;;IAA2D,QAAQ,EAAxD,OAAO,qBAAqB,EAAE,gBAAgB,CACzD;;;;IAAmB,IAAI,EAAZ,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAGE,YAAS,gBAAgB,GACzB;;;;IAAmB,aAAa,EAArB,MAAM,CACjB;;;;IAAmB,gBAAgB,EAAxB,MAAM,CACjB;;;;IAAmB,aAAa,EAArB,MAAM,CACjB;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAqB,gBAAgB,EAA1B,MAAM,EAAE,CACnB;;;;IAAqB,YAAY,EAAtB,MAAM,EAAE,CACrB;CAAA,CAAA;AAGE,YAAS,cAAc,GACvB;;;;IAAmB,KAAK,EAAb,MAAM,CACjB;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,KAAK,EAAb,MAAM,CACnB;CAAA,CAAA;AAvBD;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG"}