semantifold 0.9.0 → 0.10.0

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

@@ -0,0 +1,172 @@
+import { ProjectManifestLoader } from "./project-manifest.js";
+import { ProjectSnapshotBuilder } from "./project-snapshot.js";
+import { TargetCheckRunner } from "./target-check.js";
+/**
+ * Installs an internal synchronous orchestration observer for focused specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectBuilder} builder - Project builder instance.
+ * @param {(operation: string) => void} observer - Ordered operation observer.
+ * @returns {void}
+ */
+export declare function observeProjectBuild(builder: ProjectBuilder, observer: (operation: string) => void): void;
+/**
+ * Runs one builder invocation with the narrow snapshot-currentness controls owned by the watch coordinator.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectBuilder} builder - Project builder instance.
+ * @param {string} projectPath - Exact project manifest path.
+ * @param {ProjectBuildReporterLike} reporter - Watch-cycle reporter.
+ * @param {ProjectWatchBuildOptions} options - Checked-cycle and currentness controls.
+ * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.
+ */
+export declare function buildWatchedProject(builder: ProjectBuilder, projectPath: string, reporter: ProjectBuildReporterLike, options: ProjectWatchBuildOptions): Promise<Readonly<ProjectBuildSuccess>>;
+/**
+ * Orchestrates one complete immutable project build and one transactional publication.
+ */
+export declare class ProjectBuilder {
+    #private;
+    /**
+     * Creates a one-shot project builder.
+     * @param {{checkRunner?: TargetCheckRunner, environment?: Readonly<Record<string, string | undefined>>, manifestLoader?: ProjectManifestLoader, snapshotBuilder?: ProjectSnapshotBuilder}} [options] - Lifecycle collaborators.
+     */
+    constructor(options?: {
+        checkRunner?: TargetCheckRunner;
+        environment?: Readonly<Record<string, string | undefined>>;
+        manifestLoader?: ProjectManifestLoader;
+        snapshotBuilder?: ProjectSnapshotBuilder;
+    });
+    /**
+     * Builds and atomically publishes one project generation.
+     * @param {string} [projectPath] - Project manifest path.
+     * @param {ProjectBuildReporterLike} [reporter] - Optional state reporter.
+     * @param {ProjectBuildOptions} [options] - Optional developer-check and publication lifecycle.
+     * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.
+     */
+    build(projectPath?: string, reporter?: ProjectBuildReporterLike, options?: ProjectBuildOptions): Promise<Readonly<ProjectBuildSuccess>>;
+}
+export type ProjectBuildOptions = {
+    /**
+     * - Whether every target must run its developer check.
+     */
+    check?: boolean;
+    /**
+     * - Active check and publication cancellation authority.
+     */
+    signal?: AbortSignal;
+    /**
+     * - Per-check-stage deadline.
+     */
+    timeoutMs?: number;
+};
+export type ProjectWatchBuildOptions = {
+    /**
+     * - Whether every target must run its developer check.
+     */
+    check: boolean;
+    /**
+     * - Coordinator-reconciled complete graph hash.
+     */
+    expectedSnapshotHash: string;
+    /**
+     * - Publication-only cancellation authority.
+     */
+    publicationSignal: AbortSignal;
+    /**
+     * - Active check and publication cancellation authority.
+     */
+    signal: AbortSignal;
+    /**
+     * - Complete graph guard at the pointer boundary.
+     */
+    validateCurrentSnapshot: () => Promise<void> | void;
+};
+export type ProjectWatchBuildControls = {
+    /**
+     * - Coordinator-reconciled complete graph hash.
+     */
+    expectedSnapshotHash: string;
+    /**
+     * - Publication-only cancellation authority.
+     */
+    publicationSignal: AbortSignal;
+    /**
+     * - Complete graph guard at the pointer boundary.
+     */
+    validateCurrentSnapshot: () => Promise<void> | void;
+};
+export type ProjectBuildReporterLike = {
+    /**
+     * - Reports validated configuration.
+     */
+    projectLoaded: (projectId: string) => void;
+    /**
+     * - Reports a complete snapshot.
+     */
+    snapshotLoaded: (snapshotHash: string) => void;
+    /**
+     * - Reports generated target output.
+     */
+    targetGenerated: (target: ProjectBuildTargetResult) => void;
+    /**
+     * - Reports a successful check stage.
+     */
+    targetChecked: (checked: {
+        id: string;
+        language: string;
+        stage: import("./semantic/types.js").TargetCheckStageResult;
+    }) => void;
+};
+export type ProjectBuildTargetResult = {
+    /**
+     * - Generated artifact count.
+     */
+    artifactCount: number;
+    /**
+     * - Project target identity.
+     */
+    id: string;
+    /**
+     * - Backend target identity.
+     */
+    language: import("./semantic/types.js").BackendLanguage;
+    /**
+     * - Explicit target role.
+     */
+    role: import("./semantic/types.js").PublicationTargetRole;
+    /**
+     * - Successful developer-check evidence.
+     */
+    check?: Readonly<{
+        stages: readonly import("./semantic/types.js").TargetCheckStageResult[];
+    }>;
+};
+export type ProjectBuildSuccess = {
+    /**
+     * - Terminal success state.
+     */
+    status: "succeeded";
+    /**
+     * - Stable project identity.
+     */
+    projectId: string;
+    /**
+     * - Complete ordered input hash.
+     */
+    snapshotHash: string;
+    /**
+     * - Deterministic immutable generation identity.
+     */
+    generationId: string;
+    /**
+     * - Whether developer checks completed for every target.
+     */
+    checked: boolean;
+    /**
+     * - Ordered generated target results.
+     */
+    targets: readonly ProjectBuildTargetResult[];
+    /**
+     * - Committed publisher snapshot.
+     */
+    generation: import("./semantic/types.js").PublishedGeneration;
+};
+//# sourceMappingURL=project-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-build.d.ts","sourceRoot":"","sources":["../../src/project-build.js"],"names":[],"mappings":"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"}

package/build/src/project-build.js

@@ -0,0 +1,320 @@
+// @ts-check
+import { randomUUID } from "node:crypto";
+import { generateProgramArtifacts } from "./backends/program.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { parseProgramSource } from "./frontends/program.js";
+import { ProjectManifestLoader } from "./project-manifest.js";
+import { ProjectSnapshotBuilder } from "./project-snapshot.js";
+import { GeneratedArtifactPublisher, guardNextPublicationCommit } from "./publication.js";
+import { languageRegistry } from "./language-registry.js";
+import { createTargetCheckPlan, TargetCheckRunner } from "./target-check.js";
+import { canonicalToolchains, discoverCanonicalToolchain } from "./toolchains.js";
+/** @type {WeakMap<ProjectBuilder, (operation: string) => void>} */
+const projectBuildObservers = new WeakMap();
+/** @type {WeakMap<ProjectBuilder, ProjectWatchBuildControls[]>} */
+const projectWatchBuildControls = new WeakMap();
+/**
+ * Installs an internal synchronous orchestration observer for focused specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectBuilder} builder - Project builder instance.
+ * @param {(operation: string) => void} observer - Ordered operation observer.
+ * @returns {void}
+ */
+export function observeProjectBuild(builder, observer) {
+    if (!(builder instanceof ProjectBuilder) || typeof observer != "function") {
+        throw new TypeError("Invalid project build observer.");
+    }
+    projectBuildObservers.set(builder, observer);
+}
+/**
+ * Runs one builder invocation with the narrow snapshot-currentness controls owned by the watch coordinator.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectBuilder} builder - Project builder instance.
+ * @param {string} projectPath - Exact project manifest path.
+ * @param {ProjectBuildReporterLike} reporter - Watch-cycle reporter.
+ * @param {ProjectWatchBuildOptions} options - Checked-cycle and currentness controls.
+ * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.
+ */
+export function buildWatchedProject(builder, projectPath, reporter, options) {
+    if (!(builder instanceof ProjectBuilder) || typeof projectPath != "string" || projectPath.length == 0 ||
+        !isPlainObject(options) || Object.keys(options).some(key => !["check", "expectedSnapshotHash", "publicationSignal", "signal", "validateCurrentSnapshot"].includes(key)) ||
+        typeof options.check != "boolean" || typeof options.expectedSnapshotHash != "string" ||
+        !/^[a-f0-9]{64}$/u.test(options.expectedSnapshotHash) || !(options.publicationSignal instanceof AbortSignal) ||
+        !(options.signal instanceof AbortSignal) || typeof options.validateCurrentSnapshot != "function") {
+        throw new TypeError("Invalid watched project build controls.");
+    }
+    const queued = projectWatchBuildControls.get(builder) ?? [];
+    queued.push({
+        expectedSnapshotHash: options.expectedSnapshotHash,
+        publicationSignal: options.publicationSignal,
+        validateCurrentSnapshot: options.validateCurrentSnapshot
+    });
+    projectWatchBuildControls.set(builder, queued);
+    return builder.build(projectPath, reporter, { check: options.check, signal: options.signal });
+}
+/**
+ * Orchestrates one complete immutable project build and one transactional publication.
+ */
+export class ProjectBuilder {
+    /** @type {ProjectManifestLoader} */
+    #manifestLoader;
+    /** @type {ProjectSnapshotBuilder} */
+    #snapshotBuilder;
+    /** @type {TargetCheckRunner} */
+    #checkRunner;
+    /** @type {Readonly<Record<string, string | undefined>> | undefined} */
+    #environment;
+    /**
+     * Creates a one-shot project builder.
+     * @param {{checkRunner?: TargetCheckRunner, environment?: Readonly<Record<string, string | undefined>>, manifestLoader?: ProjectManifestLoader, snapshotBuilder?: ProjectSnapshotBuilder}} [options] - Lifecycle collaborators.
+     */
+    constructor(options = {}) {
+        if (options.checkRunner !== undefined && !(options.checkRunner instanceof TargetCheckRunner)) {
+            throw new TypeError("Project builder check runner must be a TargetCheckRunner.");
+        }
+        this.#manifestLoader = options.manifestLoader ?? new ProjectManifestLoader();
+        this.#snapshotBuilder = options.snapshotBuilder ?? new ProjectSnapshotBuilder();
+        this.#checkRunner = options.checkRunner ?? new TargetCheckRunner();
+        this.#environment = options.environment === undefined ? undefined : snapshotEnvironment(options.environment);
+    }
+    /**
+     * Builds and atomically publishes one project generation.
+     * @param {string} [projectPath] - Project manifest path.
+     * @param {ProjectBuildReporterLike} [reporter] - Optional state reporter.
+     * @param {ProjectBuildOptions} [options] - Optional developer-check and publication lifecycle.
+     * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.
+     */
+    async build(projectPath = "./semantifold.json", reporter, options = {}) {
+        const queuedWatchControls = projectWatchBuildControls.get(this);
+        const watchControls = queuedWatchControls?.shift();
+        if (queuedWatchControls?.length == 0)
+            projectWatchBuildControls.delete(this);
+        if (typeof options != "object" || options == null || Array.isArray(options) || Object.getPrototypeOf(options) != Object.prototype ||
+            Object.keys(options).some(key => !["check", "signal", "timeoutMs"].includes(key)) ||
+            options.check !== undefined && typeof options.check != "boolean" ||
+            options.signal !== undefined && !(options.signal instanceof AbortSignal) ||
+            options.timeoutMs !== undefined && (typeof options.timeoutMs != "number" || !Number.isInteger(options.timeoutMs))) {
+            throw new SemantifoldDiagnostic({
+                code: "INVALID_PROJECT_BUILD",
+                language: "project",
+                message: "Project build options require valid check, snapshot-currentness, cancellation, and timeout controls."
+            });
+        }
+        const check = options.check === true;
+        const signal = options.signal;
+        const project = await this.#manifestLoader.load(projectPath);
+        reporter?.projectLoaded(project.id);
+        const snapshot = await this.#snapshotBuilder.build(project);
+        if (watchControls !== undefined && snapshot.hash != watchControls.expectedSnapshotHash) {
+            throw new SemantifoldDiagnostic({
+                code: "WATCH_SNAPSHOT_CHANGED",
+                language: project.id,
+                message: "The complete project snapshot changed before its watch cycle began."
+            });
+        }
+        reporter?.snapshotLoaded(snapshot.hash);
+        projectBuildObservers.get(this)?.("snapshot");
+        const program = parseProgramSource({
+            entryModule: project.entryModule,
+            sources: snapshot.sources.map(source => ({
+                filename: source.path,
+                id: source.id,
+                language: source.language,
+                source: source.source
+            }))
+        });
+        projectBuildObservers.get(this)?.("parse");
+        /** @type {import("./semantic/types.js").PublicationTargetInput[]} */
+        const publicationTargets = [];
+        /** @type {ProjectBuildTargetResult[]} */
+        const targetResults = [];
+        /** @type {Map<string, import("./semantic/types.js").TargetCheckResult>} */
+        const checkResults = new Map();
+        for (const target of project.targets) {
+            if (target.role == "binary") {
+                throw new SemantifoldDiagnostic({
+                    code: "UNSUPPORTED_PROJECT_TARGET",
+                    language: target.language,
+                    message: "Complete semantic programs do not support binary project generation."
+                });
+            }
+            const artifactSet = generateProgramArtifacts({
+                language: target.language,
+                program,
+                role: target.role
+            });
+            const checkCapability = languageRegistry.record(target.language).check;
+            if (check && !checkCapability.supported) {
+                throw new SemantifoldDiagnostic({
+                    code: "UNSUPPORTED_TARGET_CHECK",
+                    language: target.language,
+                    message: `Project target '${target.id}' does not provide a developer check plan.`
+                });
+            }
+            /**
+             * Ordered candidate validators when checking is enabled.
+             * @type {import("./semantic/types.js").PublicationValidator[] | undefined}
+             */
+            const validators = check ? [async ({ buildPath, sourcePath, targetId }) => {
+                    /** @type {import("./semantic/types.js").DiscoveredToolchain[]} */
+                    const tools = [];
+                    for (const toolchain of checkCapability.toolchains) {
+                        tools.push(await discoverCanonicalToolchain(/** @type {keyof typeof canonicalToolchains} */ (toolchain), {
+                            ...(this.#environment === undefined ? {} : { environment: this.#environment })
+                        }));
+                    }
+                    const plan = createTargetCheckPlan({
+                        artifacts: artifactSet,
+                        buildPath,
+                        projectId: project.id,
+                        sourcePath,
+                        targetId,
+                        tools: Object.freeze(tools)
+                    });
+                    const result = await this.#checkRunner.run(plan, {
+                        onStage: stage => {
+                            reporter?.targetChecked({ id: target.id, language: target.language, stage });
+                            projectBuildObservers.get(this)?.(`check:${target.id}:${stage.stage}`);
+                        },
+                        ...(signal === undefined ? {} : { signal }),
+                        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })
+                    });
+                    checkResults.set(target.id, result);
+                    return [...result.outputs];
+                }] : undefined;
+            publicationTargets.push({
+                artifactSet,
+                buildProjection: target.buildProjection,
+                id: target.id,
+                role: target.role,
+                sourceProjection: target.sourceProjection,
+                ...(validators === undefined ? {} : { validators })
+            });
+            targetResults.push(Object.freeze({
+                artifactCount: artifactSet.artifacts.length,
+                id: target.id,
+                language: target.language,
+                role: target.role
+            }));
+            reporter?.targetGenerated(targetResults[targetResults.length - 1]);
+            projectBuildObservers.get(this)?.(`target:${target.id}`);
+        }
+        const publisher = new GeneratedArtifactPublisher({
+            projectId: project.id,
+            projectRoot: project.projectRoot,
+            publicationRoot: project.publicationRoot,
+            sourceFiles: project.sources.map(({ absolutePath }) => absolutePath)
+        });
+        const generationId = check
+            ? `g-${snapshot.hash}-checked-${randomUUID()}`
+            : `g-${snapshot.hash}`;
+        if (watchControls !== undefined) {
+            guardNextPublicationCommit(publisher, watchControls.validateCurrentSnapshot);
+        }
+        const publicationSignal = signal === undefined
+            ? watchControls?.publicationSignal
+            : watchControls === undefined
+                ? signal
+                : AbortSignal.any([signal, watchControls.publicationSignal]);
+        const generation = await publisher.publish({ generationId, targets: publicationTargets }, {
+            ...(publicationSignal === undefined ? {} : { signal: publicationSignal })
+        });
+        projectBuildObservers.get(this)?.("publish");
+        return Object.freeze({
+            generation,
+            generationId,
+            checked: check,
+            projectId: project.id,
+            snapshotHash: snapshot.hash,
+            status: /** @type {const} */ ("succeeded"),
+            targets: Object.freeze(targetResults.map(target => {
+                const result = checkResults.get(target.id);
+                return Object.freeze({
+                    ...target,
+                    ...(result === undefined ? {} : { check: Object.freeze({ stages: result.stages }) })
+                });
+            }))
+        });
+    }
+}
+/**
+ * @typedef ProjectBuildOptions
+ * @property {boolean} [check] - Whether every target must run its developer check.
+ * @property {AbortSignal} [signal] - Active check and publication cancellation authority.
+ * @property {number} [timeoutMs] - Per-check-stage deadline.
+ */
+/**
+ * @typedef ProjectWatchBuildOptions
+ * @property {boolean} check - Whether every target must run its developer check.
+ * @property {string} expectedSnapshotHash - Coordinator-reconciled complete graph hash.
+ * @property {AbortSignal} publicationSignal - Publication-only cancellation authority.
+ * @property {AbortSignal} signal - Active check and publication cancellation authority.
+ * @property {() => Promise<void> | void} validateCurrentSnapshot - Complete graph guard at the pointer boundary.
+ */
+/**
+ * @typedef ProjectWatchBuildControls
+ * @property {string} expectedSnapshotHash - Coordinator-reconciled complete graph hash.
+ * @property {AbortSignal} publicationSignal - Publication-only cancellation authority.
+ * @property {() => Promise<void> | void} validateCurrentSnapshot - Complete graph guard at the pointer boundary.
+ */
+/**
+ * @typedef ProjectBuildReporterLike
+ * @property {(projectId: string) => void} projectLoaded - Reports validated configuration.
+ * @property {(snapshotHash: string) => void} snapshotLoaded - Reports a complete snapshot.
+ * @property {(target: ProjectBuildTargetResult) => void} targetGenerated - Reports generated target output.
+ * @property {(checked: {id: string, language: string, stage: import("./semantic/types.js").TargetCheckStageResult}) => void} targetChecked - Reports a successful check stage.
+ */
+/**
+ * @typedef ProjectBuildTargetResult
+ * @property {number} artifactCount - Generated artifact count.
+ * @property {string} id - Project target identity.
+ * @property {import("./semantic/types.js").BackendLanguage} language - Backend target identity.
+ * @property {import("./semantic/types.js").PublicationTargetRole} role - Explicit target role.
+ * @property {Readonly<{stages: readonly import("./semantic/types.js").TargetCheckStageResult[]}>} [check] - Successful developer-check evidence.
+ */
+/**
+ * @typedef ProjectBuildSuccess
+ * @property {"succeeded"} status - Terminal success state.
+ * @property {string} projectId - Stable project identity.
+ * @property {string} snapshotHash - Complete ordered input hash.
+ * @property {string} generationId - Deterministic immutable generation identity.
+ * @property {boolean} checked - Whether developer checks completed for every target.
+ * @property {readonly ProjectBuildTargetResult[]} targets - Ordered generated target results.
+ * @property {import("./semantic/types.js").PublishedGeneration} generation - Committed publisher snapshot.
+ */
+/**
+ * Detaches explicit tool discovery configuration from caller mutation.
+ * @param {unknown} candidate - Candidate environment.
+ * @returns {Readonly<Record<string, string | undefined>>} Immutable snapshot.
+ */
+function snapshotEnvironment(candidate) {
+    if (typeof candidate != "object" || candidate == null || Array.isArray(candidate)) {
+        throw new TypeError("Project builder environment must be a plain string record.");
+    }
+    const prototype = Object.getPrototypeOf(candidate);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("Project builder environment must be a plain string record.");
+    }
+    /** @type {Record<string, string | undefined>} */
+    const snapshot = Object.create(null);
+    for (const key of Reflect.ownKeys(candidate)) {
+        if (typeof key != "string")
+            throw new TypeError("Project builder environment must use string keys.");
+        const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+        if (descriptor == undefined || !descriptor.enumerable || !("value" in descriptor) ||
+            descriptor.value !== undefined && typeof descriptor.value != "string") {
+            throw new TypeError("Project builder environment must contain string or undefined data values.");
+        }
+        snapshot[key] = descriptor.value;
+    }
+    return Object.freeze(snapshot);
+}
+/**
+ * Checks for an ordinary object-prototype record.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-build.js","sourceRoot":"","sources":["../../src/project-build.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\nimport {generateProgramArtifacts} from \"./backends/program.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {parseProgramSource} from \"./frontends/program.js\"\nimport {ProjectManifestLoader} from \"./project-manifest.js\"\nimport {ProjectSnapshotBuilder} from \"./project-snapshot.js\"\nimport {GeneratedArtifactPublisher, guardNextPublicationCommit} from \"./publication.js\"\nimport {languageRegistry} from \"./language-registry.js\"\nimport {createTargetCheckPlan, TargetCheckRunner} from \"./target-check.js\"\nimport {canonicalToolchains, discoverCanonicalToolchain} from \"./toolchains.js\"\n\n/** @type {WeakMap<ProjectBuilder, (operation: string) => void>} */\nconst projectBuildObservers = new WeakMap()\n/** @type {WeakMap<ProjectBuilder, ProjectWatchBuildControls[]>} */\nconst projectWatchBuildControls = new WeakMap()\n\n/**\n * Installs an internal synchronous orchestration observer for focused specs.\n * This helper is intentionally not part of the package root API.\n * @param {ProjectBuilder} builder - Project builder instance.\n * @param {(operation: string) => void} observer - Ordered operation observer.\n * @returns {void}\n */\nexport function observeProjectBuild(builder, observer) {\n  if (!(builder instanceof ProjectBuilder) || typeof observer != \"function\") {\n    throw new TypeError(\"Invalid project build observer.\")\n  }\n  projectBuildObservers.set(builder, observer)\n}\n\n/**\n * Runs one builder invocation with the narrow snapshot-currentness controls owned by the watch coordinator.\n * This helper is intentionally not part of the package root API.\n * @param {ProjectBuilder} builder - Project builder instance.\n * @param {string} projectPath - Exact project manifest path.\n * @param {ProjectBuildReporterLike} reporter - Watch-cycle reporter.\n * @param {ProjectWatchBuildOptions} options - Checked-cycle and currentness controls.\n * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.\n */\nexport function buildWatchedProject(builder, projectPath, reporter, options) {\n  if (!(builder instanceof ProjectBuilder) || typeof projectPath != \"string\" || projectPath.length == 0 ||\n    !isPlainObject(options) || Object.keys(options).some(key =>\n      ![\"check\", \"expectedSnapshotHash\", \"publicationSignal\", \"signal\", \"validateCurrentSnapshot\"].includes(key)) ||\n    typeof options.check != \"boolean\" || typeof options.expectedSnapshotHash != \"string\" ||\n    !/^[a-f0-9]{64}$/u.test(options.expectedSnapshotHash) || !(options.publicationSignal instanceof AbortSignal) ||\n    !(options.signal instanceof AbortSignal) || typeof options.validateCurrentSnapshot != \"function\") {\n    throw new TypeError(\"Invalid watched project build controls.\")\n  }\n  const queued = projectWatchBuildControls.get(builder) ?? []\n\n  queued.push({\n    expectedSnapshotHash: options.expectedSnapshotHash,\n    publicationSignal: options.publicationSignal,\n    validateCurrentSnapshot: options.validateCurrentSnapshot\n  })\n  projectWatchBuildControls.set(builder, queued)\n\n  return builder.build(projectPath, reporter, {check: options.check, signal: options.signal})\n}\n\n/**\n * Orchestrates one complete immutable project build and one transactional publication.\n */\nexport class ProjectBuilder {\n  /** @type {ProjectManifestLoader} */\n  #manifestLoader\n  /** @type {ProjectSnapshotBuilder} */\n  #snapshotBuilder\n  /** @type {TargetCheckRunner} */\n  #checkRunner\n  /** @type {Readonly<Record<string, string | undefined>> | undefined} */\n  #environment\n\n  /**\n   * Creates a one-shot project builder.\n   * @param {{checkRunner?: TargetCheckRunner, environment?: Readonly<Record<string, string | undefined>>, manifestLoader?: ProjectManifestLoader, snapshotBuilder?: ProjectSnapshotBuilder}} [options] - Lifecycle collaborators.\n   */\n  constructor(options = {}) {\n    if (options.checkRunner !== undefined && !(options.checkRunner instanceof TargetCheckRunner)) {\n      throw new TypeError(\"Project builder check runner must be a TargetCheckRunner.\")\n    }\n    this.#manifestLoader = options.manifestLoader ?? new ProjectManifestLoader()\n    this.#snapshotBuilder = options.snapshotBuilder ?? new ProjectSnapshotBuilder()\n    this.#checkRunner = options.checkRunner ?? new TargetCheckRunner()\n    this.#environment = options.environment === undefined ? undefined : snapshotEnvironment(options.environment)\n  }\n\n  /**\n   * Builds and atomically publishes one project generation.\n   * @param {string} [projectPath] - Project manifest path.\n   * @param {ProjectBuildReporterLike} [reporter] - Optional state reporter.\n   * @param {ProjectBuildOptions} [options] - Optional developer-check and publication lifecycle.\n   * @returns {Promise<Readonly<ProjectBuildSuccess>>} Committed build result.\n   */\n  async build(projectPath = \"./semantifold.json\", reporter, options = {}) {\n    const queuedWatchControls = projectWatchBuildControls.get(this)\n    const watchControls = queuedWatchControls?.shift()\n\n    if (queuedWatchControls?.length == 0) projectWatchBuildControls.delete(this)\n    if (typeof options != \"object\" || options == null || Array.isArray(options) || Object.getPrototypeOf(options) != Object.prototype ||\n      Object.keys(options).some(key => ![\"check\", \"signal\", \"timeoutMs\"].includes(key)) ||\n      options.check !== undefined && typeof options.check != \"boolean\" ||\n      options.signal !== undefined && !(options.signal instanceof AbortSignal) ||\n      options.timeoutMs !== undefined && (typeof options.timeoutMs != \"number\" || !Number.isInteger(options.timeoutMs))) {\n      throw new SemantifoldDiagnostic({\n        code: \"INVALID_PROJECT_BUILD\",\n        language: \"project\",\n        message: \"Project build options require valid check, snapshot-currentness, cancellation, and timeout controls.\"\n      })\n    }\n    const check = options.check === true\n    const signal = options.signal\n    const project = await this.#manifestLoader.load(projectPath)\n\n    reporter?.projectLoaded(project.id)\n    const snapshot = await this.#snapshotBuilder.build(project)\n\n    if (watchControls !== undefined && snapshot.hash != watchControls.expectedSnapshotHash) {\n      throw new SemantifoldDiagnostic({\n        code: \"WATCH_SNAPSHOT_CHANGED\",\n        language: project.id,\n        message: \"The complete project snapshot changed before its watch cycle began.\"\n      })\n    }\n\n    reporter?.snapshotLoaded(snapshot.hash)\n    projectBuildObservers.get(this)?.(\"snapshot\")\n    const program = parseProgramSource({\n      entryModule: project.entryModule,\n      sources: snapshot.sources.map(source => ({\n        filename: source.path,\n        id: source.id,\n        language: source.language,\n        source: source.source\n      }))\n    })\n\n    projectBuildObservers.get(this)?.(\"parse\")\n    /** @type {import(\"./semantic/types.js\").PublicationTargetInput[]} */\n    const publicationTargets = []\n    /** @type {ProjectBuildTargetResult[]} */\n    const targetResults = []\n    /** @type {Map<string, import(\"./semantic/types.js\").TargetCheckResult>} */\n    const checkResults = new Map()\n\n    for (const target of project.targets) {\n      if (target.role == \"binary\") {\n        throw new SemantifoldDiagnostic({\n          code: \"UNSUPPORTED_PROJECT_TARGET\",\n          language: target.language,\n          message: \"Complete semantic programs do not support binary project generation.\"\n        })\n      }\n      const artifactSet = generateProgramArtifacts({\n        language: target.language,\n        program,\n        role: target.role\n      })\n      const checkCapability = languageRegistry.record(target.language).check\n\n      if (check && !checkCapability.supported) {\n        throw new SemantifoldDiagnostic({\n          code: \"UNSUPPORTED_TARGET_CHECK\",\n          language: target.language,\n          message: `Project target '${target.id}' does not provide a developer check plan.`\n        })\n      }\n      /**\n       * Ordered candidate validators when checking is enabled.\n       * @type {import(\"./semantic/types.js\").PublicationValidator[] | undefined}\n       */\n      const validators = check ? [async ({buildPath, sourcePath, targetId}) => {\n        /** @type {import(\"./semantic/types.js\").DiscoveredToolchain[]} */\n        const tools = []\n\n        for (const toolchain of checkCapability.toolchains) {\n          tools.push(await discoverCanonicalToolchain(/** @type {keyof typeof canonicalToolchains} */ (toolchain), {\n            ...(this.#environment === undefined ? {} : {environment: this.#environment})\n          }))\n        }\n        const plan = createTargetCheckPlan({\n          artifacts: artifactSet,\n          buildPath,\n          projectId: project.id,\n          sourcePath,\n          targetId,\n          tools: Object.freeze(tools)\n        })\n        const result = await this.#checkRunner.run(plan, {\n          onStage: stage => {\n            reporter?.targetChecked({id: target.id, language: target.language, stage})\n            projectBuildObservers.get(this)?.(`check:${target.id}:${stage.stage}`)\n          },\n          ...(signal === undefined ? {} : {signal}),\n          ...(options.timeoutMs === undefined ? {} : {timeoutMs: options.timeoutMs})\n        })\n\n        checkResults.set(target.id, result)\n\n        return [...result.outputs]\n      }] : undefined\n\n      publicationTargets.push({\n        artifactSet,\n        buildProjection: target.buildProjection,\n        id: target.id,\n        role: target.role,\n        sourceProjection: target.sourceProjection,\n        ...(validators === undefined ? {} : {validators})\n      })\n      targetResults.push(Object.freeze({\n        artifactCount: artifactSet.artifacts.length,\n        id: target.id,\n        language: target.language,\n        role: target.role\n      }))\n      reporter?.targetGenerated(targetResults[targetResults.length - 1])\n      projectBuildObservers.get(this)?.(`target:${target.id}`)\n    }\n    const publisher = new GeneratedArtifactPublisher({\n      projectId: project.id,\n      projectRoot: project.projectRoot,\n      publicationRoot: project.publicationRoot,\n      sourceFiles: project.sources.map(({absolutePath}) => absolutePath)\n    })\n    const generationId = check\n      ? `g-${snapshot.hash}-checked-${randomUUID()}`\n      : `g-${snapshot.hash}`\n    if (watchControls !== undefined) {\n      guardNextPublicationCommit(publisher, watchControls.validateCurrentSnapshot)\n    }\n    const publicationSignal = signal === undefined\n      ? watchControls?.publicationSignal\n      : watchControls === undefined\n        ? signal\n        : AbortSignal.any([signal, watchControls.publicationSignal])\n    const generation = await publisher.publish({generationId, targets: publicationTargets}, {\n      ...(publicationSignal === undefined ? {} : {signal: publicationSignal})\n    })\n\n    projectBuildObservers.get(this)?.(\"publish\")\n\n    return Object.freeze({\n      generation,\n      generationId,\n      checked: check,\n      projectId: project.id,\n      snapshotHash: snapshot.hash,\n      status: /** @type {const} */ (\"succeeded\"),\n      targets: Object.freeze(targetResults.map(target => {\n        const result = checkResults.get(target.id)\n\n        return Object.freeze({\n          ...target,\n          ...(result === undefined ? {} : {check: Object.freeze({stages: result.stages})})\n        })\n      }))\n    })\n  }\n}\n\n/**\n * @typedef ProjectBuildOptions\n * @property {boolean} [check] - Whether every target must run its developer check.\n * @property {AbortSignal} [signal] - Active check and publication cancellation authority.\n * @property {number} [timeoutMs] - Per-check-stage deadline.\n */\n\n/**\n * @typedef ProjectWatchBuildOptions\n * @property {boolean} check - Whether every target must run its developer check.\n * @property {string} expectedSnapshotHash - Coordinator-reconciled complete graph hash.\n * @property {AbortSignal} publicationSignal - Publication-only cancellation authority.\n * @property {AbortSignal} signal - Active check and publication cancellation authority.\n * @property {() => Promise<void> | void} validateCurrentSnapshot - Complete graph guard at the pointer boundary.\n */\n\n/**\n * @typedef ProjectWatchBuildControls\n * @property {string} expectedSnapshotHash - Coordinator-reconciled complete graph hash.\n * @property {AbortSignal} publicationSignal - Publication-only cancellation authority.\n * @property {() => Promise<void> | void} validateCurrentSnapshot - Complete graph guard at the pointer boundary.\n */\n\n/**\n * @typedef ProjectBuildReporterLike\n * @property {(projectId: string) => void} projectLoaded - Reports validated configuration.\n * @property {(snapshotHash: string) => void} snapshotLoaded - Reports a complete snapshot.\n * @property {(target: ProjectBuildTargetResult) => void} targetGenerated - Reports generated target output.\n * @property {(checked: {id: string, language: string, stage: import(\"./semantic/types.js\").TargetCheckStageResult}) => void} targetChecked - Reports a successful check stage.\n */\n\n/**\n * @typedef ProjectBuildTargetResult\n * @property {number} artifactCount - Generated artifact count.\n * @property {string} id - Project target identity.\n * @property {import(\"./semantic/types.js\").BackendLanguage} language - Backend target identity.\n * @property {import(\"./semantic/types.js\").PublicationTargetRole} role - Explicit target role.\n * @property {Readonly<{stages: readonly import(\"./semantic/types.js\").TargetCheckStageResult[]}>} [check] - Successful developer-check evidence.\n */\n\n/**\n * @typedef ProjectBuildSuccess\n * @property {\"succeeded\"} status - Terminal success state.\n * @property {string} projectId - Stable project identity.\n * @property {string} snapshotHash - Complete ordered input hash.\n * @property {string} generationId - Deterministic immutable generation identity.\n * @property {boolean} checked - Whether developer checks completed for every target.\n * @property {readonly ProjectBuildTargetResult[]} targets - Ordered generated target results.\n * @property {import(\"./semantic/types.js\").PublishedGeneration} generation - Committed publisher snapshot.\n */\n\n/**\n * Detaches explicit tool discovery configuration from caller mutation.\n * @param {unknown} candidate - Candidate environment.\n * @returns {Readonly<Record<string, string | undefined>>} Immutable snapshot.\n */\nfunction snapshotEnvironment(candidate) {\n  if (typeof candidate != \"object\" || candidate == null || Array.isArray(candidate)) {\n    throw new TypeError(\"Project builder environment must be a plain string record.\")\n  }\n  const prototype = Object.getPrototypeOf(candidate)\n\n  if (prototype !== Object.prototype && prototype !== null) {\n    throw new TypeError(\"Project builder environment must be a plain string record.\")\n  }\n  /** @type {Record<string, string | undefined>} */\n  const snapshot = Object.create(null)\n\n  for (const key of Reflect.ownKeys(candidate)) {\n    if (typeof key != \"string\") throw new TypeError(\"Project builder environment must use string keys.\")\n    const descriptor = Object.getOwnPropertyDescriptor(candidate, key)\n\n    if (descriptor == undefined || !descriptor.enumerable || !(\"value\" in descriptor) ||\n      descriptor.value !== undefined && typeof descriptor.value != \"string\") {\n      throw new TypeError(\"Project builder environment must contain string or undefined data values.\")\n    }\n    snapshot[key] = descriptor.value\n  }\n\n  return Object.freeze(snapshot)\n}\n\n/**\n * Checks for an ordinary object-prototype record.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n"]}

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

@@ -0,0 +1,40 @@
+import { ProjectBuilder } from "./project-build.js";
+import { ProjectWatchCoordinator } from "./project-watch.js";
+/**
+ * Owns one strict command invocation while delegating durable build behavior.
+ */
+export declare class SemantifoldCli {
+    #private;
+    /**
+     * Creates an importable CLI lifecycle.
+     * @param {{builder?: ProjectBuilder, coordinator?: ProjectWatchCoordinator, stderr?: import("./project-reporter.js").WritableOutput, stdout?: import("./project-reporter.js").WritableOutput}} [options] - Collaborators and sinks.
+     */
+    constructor(options?: {
+        builder?: ProjectBuilder;
+        coordinator?: ProjectWatchCoordinator;
+        stderr?: import("./project-reporter.js").WritableOutput;
+        stdout?: import("./project-reporter.js").WritableOutput;
+    });
+    /**
+     * Runs one command without mutating process exit state.
+     * @param {readonly string[]} arguments_ - Arguments after the executable name.
+     * @returns {Promise<0 | 1>} Exact process status.
+     */
+    run(arguments_: readonly string[]): Promise<0 | 1>;
+}
+/**
+ * Parses the intentionally narrow one-shot CLI grammar.
+ * @param {readonly string[]} arguments_ - Arguments after the executable name.
+ * @returns {Readonly<{check: boolean, format: "human" | "ndjson", projectPath: string}> | Readonly<{command: "watch", check: boolean, format: "human" | "ndjson", projectPath: string}>} Validated command options.
+ */
+export declare function parseSemantifoldCliArguments(arguments_: readonly string[]): Readonly<{
+    check: boolean;
+    format: "human" | "ndjson";
+    projectPath: string;
+}> | Readonly<{
+    command: "watch";
+    check: boolean;
+    format: "human" | "ndjson";
+    projectPath: string;
+}>;
+//# sourceMappingURL=project-cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-cli.d.ts","sourceRoot":"","sources":["../../src/project-cli.js"],"names":[],"mappings":"AAGA,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAA;AAEjD,OAAO,EAAC,uBAAuB,EAAC,MAAM,oBAAoB,CAAA;AAG1D;;GAEG;AACH,qBAAa,cAAc;;IAUzB;;;OAGG;IACH,YAAY,OAAO,AAFhB,CACF,EADU;QAAC,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,uBAAuB,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,uBAAuB,EAAE,cAAc,CAAA;KAErK,EAKvB;IAED;;;;OAIG;IACG,GAAG,CAAC,UAAU,EAHT,SAAS,MAAM,EAGN,GAFP,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAuD1B;CACF;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAH5C,SAAS,MAAM,EAG6B,GAF1C,QAAQ,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,GAAG,QAAQ,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,CA6CvL"}