@interf/compiler 0.22.0 → 0.33.0

package/dist/packages/project/interf-scaffold.js

@@ -1,136 +0,0 @@
-import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
-import { basename, join, relative, sep } from "node:path";
-import { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
-import { loadBuildPlanDefinitionFromDir, seedLocalDefaultBuildPlan } from "../build-plans/package/local-build-plans.js";
-import { initializeBuildRuntimeState, } from "../engine/build/state.js";
-import { refreshVerifiableContextBootstrapGuidance } from "../engine/agents/lib/verifiable-context-bootstrap.js";
-import { assertVerifiableContextContainer, assertVerifiableContextName, } from "./interf-detect.js";
-import { seedVerifiableContextBuildPlanPackage } from "../build-plans/package/interf-build-plan-package.js";
-import { asPreparationDataDir, preparationVerifiableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { ensureBuildPlanArtifactTargets, listBuildPlanContextArtifacts, readBuildPlanContextFile } from "../engine/build/verifiable-context-schema.js";
-import { findSourcePreparationConfig, loadSourceFolderConfig, buildPlanIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, saveVerifiableContextInterfConfig, } from "./source-config.js";
-import { defaultControlPathForVerifiableContext, testRootForVerifiableContext, buildPlanPackagePathForVerifiableContext } from "../engine/build/verifiable-context-paths.js";
-import { DEFAULT_BUILD_PLAN_ID } from "../build-plans/build-plan-resolution.js";
-const DEFAULT_INTERFIGNORE = [
-    ".claude/",
-    ".codex/",
-    ".agents/",
-    ".cursor/",
-    ".interf/tests/",
-    ".interf/tests/targets/sandboxes/",
-    ".interf/runtime/",
-    "",
-].join("\n");
-const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet built. Run `interf build` to build this verifiable context.";
-function renderUnbuiltVerifiableContextFile(verifiableContextName, relativePath, about) {
-    return [
-        `# ${verifiableContextName} — ${relativePath}`,
-        "",
-        UNCOMPILED_COMPILED_PLACEHOLDER,
-        ...(about ? ["", `About: ${about}`] : []),
-        "",
-    ].join("\n");
-}
-function verifiableContextGitignoreEntries(verifiableContextPath) {
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
-    const artifactEntries = (schema ? listBuildPlanContextArtifacts(schema) : [])
-        .filter((artifact) => artifact.kind !== "runtime")
-        .map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`);
-    return [
-        ...artifactEntries,
-        ".claude/",
-        ".codex/",
-        ".agents/",
-        ".cursor/",
-        ".interf/tests/",
-        ".interf/tests/targets/sandboxes/",
-        ".interf/runtime/",
-    ];
-}
-function scaffoldVerifiableContextOutputs(verifiableContextPath, verifiableContextName, about) {
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
-    if (!schema) {
-        throw new Error(`Missing Build Plan schema at ${buildPlanPackagePathForVerifiableContext(verifiableContextPath)}.`);
-    }
-    ensureBuildPlanArtifactTargets(verifiableContextPath, schema);
-    for (const artifact of listBuildPlanContextArtifacts(schema)) {
-        if (!artifact.required || artifact.kind !== "file" || artifact.role !== "output")
-            continue;
-        const targetPath = join(verifiableContextPath, artifact.path);
-        if (existsSync(targetPath))
-            continue;
-        writeFileSync(targetPath, renderUnbuiltVerifiableContextFile(verifiableContextName, artifact.path, about));
-    }
-}
-function localBuildPlanMatches(verifiableContextPath, buildPlanId) {
-    const localBuildPlan = loadBuildPlanDefinitionFromDir(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
-    return localBuildPlan?.id === buildPlanId;
-}
-export function ensureVerifiableContextScaffold(prepDataDir, preparationName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
-    assertVerifiableContextName(preparationName, "Verifiable context");
-    assertVerifiableContextContainer(prepDataDir);
-    const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparationName);
-    mkdirSync(verifiableContextPath, { recursive: true });
-    mkdirSync(testRootForVerifiableContext(verifiableContextPath), { recursive: true });
-    if (buildPlanId === "interf-default") {
-        seedLocalDefaultBuildPlan({ prepDataDir });
-    }
-    const selectedBuildPlan = getBuildPlan(buildPlanId, { prepDataDir });
-    if (!localBuildPlanMatches(verifiableContextPath, selectedBuildPlan.id)) {
-        seedVerifiableContextBuildPlanPackage({
-            verifiableContextPath,
-            prepDataDir,
-            buildPlanId: selectedBuildPlan.id,
-        });
-    }
-    if (!existsSync(join(verifiableContextPath, ".gitignore"))) {
-        writeFileSync(join(verifiableContextPath, ".gitignore"), [...verifiableContextGitignoreEntries(verifiableContextPath), ""].join("\n"));
-    }
-    return verifiableContextPath;
-}
-export function createVerifiableContext(name, prepDataDir, buildPlanId = DEFAULT_BUILD_PLAN_ID, about, sourceFolderPath) {
-    assertVerifiableContextName(name, "Verifiable context");
-    if (!sourceFolderPath || typeof sourceFolderPath !== "string") {
-        throw new Error("createVerifiableContext requires an explicit sourceFolderPath. Pass the absolute Source Folder path the verifiable context binds to.");
-    }
-    const savedPreparation = findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), name);
-    const effectiveBuildPlanId = buildPlanIdForSourcePreparationConfig(savedPreparation) ?? buildPlanId;
-    const selectedBuildPlan = getBuildPlan(effectiveBuildPlanId, { prepDataDir });
-    const verifiableContextPath = ensureVerifiableContextScaffold(prepDataDir, name, selectedBuildPlan.id);
-    const resolvedAbout = about ?? savedPreparation?.about;
-    const resolvedSourceFolderPath = savedPreparation
-        ? resolveConfiguredSourceFolderPath(prepDataDir) ?? resolveSourcePreparationPath(prepDataDir, savedPreparation)
-        : sourceFolderPath;
-    const sourceRelativePath = relative(verifiableContextPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
-    saveVerifiableContextInterfConfig(verifiableContextPath, {
-        type: "verifiable-context",
-        name,
-        ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        build_plan: selectedBuildPlan.id,
-        ...(typeof savedPreparation?.max_attempts === "number"
-            ? { max_attempts: savedPreparation.max_attempts }
-            : {}),
-        ...(typeof savedPreparation?.max_loops === "number"
-            ? { max_loops: savedPreparation.max_loops }
-            : {}),
-        checks: savedPreparation?.checks ?? [],
-        build_plan_origin: {
-            selected: selectedBuildPlan.id,
-            local_draft: false,
-        },
-        source: {
-            path: sourceRelativePath,
-            control_path: defaultControlPathForVerifiableContext(verifiableContextPath),
-            preparation_path: sourceRelativePath,
-        },
-    });
-    writeFileSync(join(verifiableContextPath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    scaffoldVerifiableContextOutputs(verifiableContextPath, name, about);
-    refreshVerifiableContextBootstrapGuidance(verifiableContextPath);
-    writeFileSync(join(verifiableContextPath, ".gitignore"), [...verifiableContextGitignoreEntries(verifiableContextPath), ""].join("\n"));
-    initializeBuildRuntimeState(verifiableContextPath);
-    return verifiableContextPath;
-}
-export function defaultVerifiableContextNameForSource(prepDataDir) {
-    return basename(prepDataDir);
-}

package/dist/packages/project/interf.d.ts

@@ -1,4 +0,0 @@
-export { INTERF_CONTAINER_NAME, BUILD_PLAN_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, BUILD_PLAN_PACKAGE_DIR, readInterfConfig, detectInterf, resolveVerifiableContext, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listVerifiableContextsForSourceFolder, hasSourceFolderInput, assertVerifiableContextContainer, assertWritableTargetDir, assertVerifiableContextName, } from "./interf-detect.js";
-export type { InterfConfig, ResolvedVerifiableContext } from "./interf-detect.js";
-export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createVerifiableContext, defaultVerifiableContextNameForSource, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project/interf.js

@@ -1,3 +0,0 @@
-export { INTERF_CONTAINER_NAME, BUILD_PLAN_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, BUILD_PLAN_PACKAGE_DIR, readInterfConfig, detectInterf, resolveVerifiableContext, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listVerifiableContextsForSourceFolder, hasSourceFolderInput, assertVerifiableContextContainer, assertWritableTargetDir, assertVerifiableContextName, } from "./interf-detect.js";
-export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createVerifiableContext, defaultVerifiableContextNameForSource, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project/lib/schema.d.ts

@@ -1,328 +0,0 @@
-import { z } from "zod";
-import { BuildPlanIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
-export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
-export declare const SourceReadinessCheckSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    question: z.ZodString;
-    answer: z.ZodOptional<z.ZodString>;
-    expect: z.ZodOptional<z.ZodObject<{
-        must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-        must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        min_words: z.ZodOptional<z.ZodNumber>;
-        max_words: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    strictness: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const RequestedArtifactCheckSchema: z.ZodObject<{
-    label: z.ZodString;
-}, z.core.$loose>;
-export declare const RequestedArtifactOutputSchema: z.ZodObject<{
-    path: z.ZodOptional<z.ZodString>;
-    shape: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodLiteral<"path">;
-        path: z.ZodString;
-        artifact_kind: z.ZodEnum<{
-            file: "file";
-            directory: "directory";
-        }>;
-    }, z.core.$strict>>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodEnum<{
-            file_exists: "file_exists";
-            min_file_count: "min_file_count";
-            min_file_count_matches_source: "min_file_count_matches_source";
-            frontmatter_valid: "frontmatter_valid";
-            frontmatter_required_keys: "frontmatter_required_keys";
-            wikilinks_valid: "wikilinks_valid";
-            must_not_contain: "must_not_contain";
-            must_contain: "must_contain";
-            qa_match: "qa_match";
-        }>;
-        description: z.ZodOptional<z.ZodString>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        required: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strict>>>;
-    stage_hint: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const RequestedArtifactSchema: z.ZodPreprocess<z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    title: z.ZodString;
-    purpose: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        label: z.ZodString;
-    }, z.core.$loose>]>>>;
-    output: z.ZodOptional<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        shape: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodLiteral<"path">;
-            path: z.ZodString;
-            artifact_kind: z.ZodEnum<{
-                file: "file";
-                directory: "directory";
-            }>;
-        }, z.core.$strict>>;
-        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            kind: z.ZodEnum<{
-                file_exists: "file_exists";
-                min_file_count: "min_file_count";
-                min_file_count_matches_source: "min_file_count_matches_source";
-                frontmatter_valid: "frontmatter_valid";
-                frontmatter_required_keys: "frontmatter_required_keys";
-                wikilinks_valid: "wikilinks_valid";
-                must_not_contain: "must_not_contain";
-                must_contain: "must_contain";
-                qa_match: "qa_match";
-            }>;
-            description: z.ZodOptional<z.ZodString>;
-            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            required: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strict>>>;
-        stage_hint: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>>;
-export declare const SourceProfileItemSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-    kind: z.ZodOptional<z.ZodString>;
-    page_count: z.ZodOptional<z.ZodNumber>;
-    note: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export declare const SourceProfileSchema: z.ZodObject<{
-    summary: z.ZodOptional<z.ZodString>;
-    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        path: z.ZodOptional<z.ZodString>;
-        kind: z.ZodOptional<z.ZodString>;
-        page_count: z.ZodOptional<z.ZodNumber>;
-        note: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>>;
-    observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$loose>;
-export declare const SourcePreparationConfigSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    path: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    build_plan: z.ZodOptional<z.ZodString>;
-    max_attempts: z.ZodOptional<z.ZodNumber>;
-    max_loops: z.ZodOptional<z.ZodNumber>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        question: z.ZodString;
-        answer: z.ZodOptional<z.ZodString>;
-        expect: z.ZodOptional<z.ZodObject<{
-            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            min_words: z.ZodOptional<z.ZodNumber>;
-            max_words: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        strictness: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        purpose: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            label: z.ZodString;
-        }, z.core.$loose>]>>>;
-        output: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            shape: z.ZodOptional<z.ZodObject<{
-                kind: z.ZodLiteral<"path">;
-                path: z.ZodString;
-                artifact_kind: z.ZodEnum<{
-                    file: "file";
-                    directory: "directory";
-                }>;
-            }, z.core.$strict>>;
-            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                kind: z.ZodEnum<{
-                    file_exists: "file_exists";
-                    min_file_count: "min_file_count";
-                    min_file_count_matches_source: "min_file_count_matches_source";
-                    frontmatter_valid: "frontmatter_valid";
-                    frontmatter_required_keys: "frontmatter_required_keys";
-                    wikilinks_valid: "wikilinks_valid";
-                    must_not_contain: "must_not_contain";
-                    must_contain: "must_contain";
-                    qa_match: "qa_match";
-                }>;
-                description: z.ZodOptional<z.ZodString>;
-                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                required: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strict>>>;
-            stage_hint: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>>>;
-    source_profile: z.ZodOptional<z.ZodObject<{
-        summary: z.ZodOptional<z.ZodString>;
-        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            path: z.ZodOptional<z.ZodString>;
-            kind: z.ZodOptional<z.ZodString>;
-            page_count: z.ZodOptional<z.ZodNumber>;
-            note: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>>;
-        observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$loose>>;
-}, z.core.$strict>;
-export declare const SourceFolderBindingSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$loose>;
-export declare const VerifiableContextInterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"verifiable-context">;
-    name: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    build_plan: z.ZodString;
-    max_attempts: z.ZodOptional<z.ZodNumber>;
-    max_loops: z.ZodOptional<z.ZodNumber>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        question: z.ZodString;
-        answer: z.ZodOptional<z.ZodString>;
-        expect: z.ZodOptional<z.ZodObject<{
-            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            min_words: z.ZodOptional<z.ZodNumber>;
-            max_words: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        strictness: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    build_plan_origin: z.ZodOptional<z.ZodObject<{
-        selected: z.ZodString;
-        local_draft: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    source: z.ZodObject<{
-        path: z.ZodString;
-        control_path: z.ZodOptional<z.ZodString>;
-        preparation_path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$loose>;
-export declare const InterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"verifiable-context">;
-    name: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    build_plan: z.ZodString;
-    max_attempts: z.ZodOptional<z.ZodNumber>;
-    max_loops: z.ZodOptional<z.ZodNumber>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        question: z.ZodString;
-        answer: z.ZodOptional<z.ZodString>;
-        expect: z.ZodOptional<z.ZodObject<{
-            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            min_words: z.ZodOptional<z.ZodNumber>;
-            max_words: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        strictness: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    build_plan_origin: z.ZodOptional<z.ZodObject<{
-        selected: z.ZodString;
-        local_draft: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    source: z.ZodObject<{
-        path: z.ZodString;
-        control_path: z.ZodOptional<z.ZodString>;
-        preparation_path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$loose>;
-export declare const SourceFolderConfigSchema: z.ZodObject<{
-    source_folder: z.ZodOptional<z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$loose>>;
-    preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        path: z.ZodString;
-        about: z.ZodOptional<z.ZodString>;
-        build_plan: z.ZodOptional<z.ZodString>;
-        max_attempts: z.ZodOptional<z.ZodNumber>;
-        max_loops: z.ZodOptional<z.ZodNumber>;
-        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            question: z.ZodString;
-            answer: z.ZodOptional<z.ZodString>;
-            expect: z.ZodOptional<z.ZodObject<{
-                must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-                must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                min_words: z.ZodOptional<z.ZodNumber>;
-                max_words: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            strictness: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            title: z.ZodString;
-            purpose: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                label: z.ZodString;
-            }, z.core.$loose>]>>>;
-            output: z.ZodOptional<z.ZodObject<{
-                path: z.ZodOptional<z.ZodString>;
-                shape: z.ZodOptional<z.ZodObject<{
-                    kind: z.ZodLiteral<"path">;
-                    path: z.ZodString;
-                    artifact_kind: z.ZodEnum<{
-                        file: "file";
-                        directory: "directory";
-                    }>;
-                }, z.core.$strict>>;
-                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                    id: z.ZodString;
-                    kind: z.ZodEnum<{
-                        file_exists: "file_exists";
-                        min_file_count: "min_file_count";
-                        min_file_count_matches_source: "min_file_count_matches_source";
-                        frontmatter_valid: "frontmatter_valid";
-                        frontmatter_required_keys: "frontmatter_required_keys";
-                        wikilinks_valid: "wikilinks_valid";
-                        must_not_contain: "must_not_contain";
-                        must_contain: "must_contain";
-                        qa_match: "qa_match";
-                    }>;
-                    description: z.ZodOptional<z.ZodString>;
-                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    required: z.ZodDefault<z.ZodBoolean>;
-                }, z.core.$strict>>>;
-                stage_hint: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>>>;
-        source_profile: z.ZodOptional<z.ZodObject<{
-            summary: z.ZodOptional<z.ZodString>;
-            items: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                name: z.ZodOptional<z.ZodString>;
-                path: z.ZodOptional<z.ZodString>;
-                kind: z.ZodOptional<z.ZodString>;
-                page_count: z.ZodOptional<z.ZodNumber>;
-                note: z.ZodOptional<z.ZodString>;
-            }, z.core.$loose>>>;
-            observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$loose>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
-export type RequestedArtifactCheck = z.infer<typeof RequestedArtifactCheckSchema>;
-export type RequestedArtifact = z.infer<typeof RequestedArtifactSchema>;
-export type RequestedArtifactOutput = z.infer<typeof RequestedArtifactOutputSchema>;
-export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
-export type SourceProfile = z.infer<typeof SourceProfileSchema>;
-export type PreparationName = z.infer<typeof PreparationNameSchema>;
-export type BuildPlanId = z.infer<typeof BuildPlanIdSchema>;
-export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;
-export type InterfConfig = z.infer<typeof InterfConfigSchema>;
-export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;

package/dist/packages/project/lib/schema.js

@@ -1,136 +0,0 @@
-import { z } from "zod";
-import { isAbsolute, normalize } from "node:path";
-import { ArtifactPathShapeSchema, CheckSchema, InterfIdPattern, BuildPlanIdSchema, PreparationNameSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
-export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
-/**
- * Absolute paths that an attacker-controlled config must never reach. The
- * build runtime treats `preparation.path` as a filesystem instruction — letting
- * a browser-tab forge `/etc` or `/sys` could mutate or read system state.
- * The list mirrors the CSO review allowlist.
- */
-const FORBIDDEN_ABSOLUTE_PATH_PREFIXES = [
-    "/etc",
-    "/sys",
-    "/proc",
-    "/dev",
-    "/var/run",
-    "/var/lib",
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/boot",
-];
-function isForbiddenAbsolutePath(value) {
-    if (!isAbsolute(value))
-        return false;
-    const normalized = normalize(value);
-    for (const prefix of FORBIDDEN_ABSOLUTE_PATH_PREFIXES) {
-        if (normalized === prefix || normalized.startsWith(`${prefix}/`))
-            return true;
-    }
-    return false;
-}
-export const SourceReadinessCheckSchema = z.object({
-    id: z.string().regex(InterfIdPattern).optional(),
-    question: z.string().min(1),
-    answer: z.string().min(1).optional(),
-    expect: TestCaseExpectSchema.optional(),
-    strictness: z.string().min(1).optional(),
-}).strict().superRefine((value, ctx) => {
-    if (!value.answer && !value.expect) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["answer"],
-            message: "Readiness checks need `answer` or `expect`.",
-        });
-    }
-});
-export const RequestedArtifactCheckSchema = z.object({
-    label: z.string().min(1),
-}).passthrough();
-export const RequestedArtifactOutputSchema = z.object({
-    path: z.string().min(1).optional(),
-    shape: ArtifactPathShapeSchema.optional(),
-    checks: z.array(CheckSchema).default([]),
-    stage_hint: z.string().min(1).optional(),
-}).strict();
-const RequestedArtifactObjectSchema = z.object({
-    id: z.string().min(1).optional(),
-    title: z.string().min(1),
-    purpose: z.string().min(1).optional(),
-    description: z.string().min(1).optional(),
-    checks: z.array(z.union([z.string().min(1), RequestedArtifactCheckSchema])).default([]),
-    output: RequestedArtifactOutputSchema.optional(),
-}).strict();
-export const RequestedArtifactSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const record = value;
-    if (typeof record.title === "string" && record.title.trim().length > 0)
-        return value;
-    const title = typeof record.label === "string"
-        ? record.label
-        : typeof record.name === "string"
-            ? record.name
-            : null;
-    return title ? { ...record, title } : value;
-}, RequestedArtifactObjectSchema);
-export const SourceProfileItemSchema = z.object({
-    name: z.string().min(1).optional(),
-    path: z.string().min(1).optional(),
-    kind: z.string().min(1).optional(),
-    page_count: z.number().int().nonnegative().optional(),
-    note: z.string().min(1).optional(),
-}).passthrough();
-export const SourceProfileSchema = z.object({
-    summary: z.string().min(1).optional(),
-    items: z.array(SourceProfileItemSchema).default([]),
-    observations: z.array(z.string().min(1)).default([]),
-    limitations: z.array(z.string().min(1)).default([]),
-}).passthrough();
-export const SourcePreparationConfigSchema = z.object({
-    id: z.string().regex(InterfIdPattern).optional(),
-    name: PreparationNameSchema,
-    path: z
-        .string()
-        .min(1)
-        .refine((value) => !isForbiddenAbsolutePath(value), {
-        message: "Preparation path may not target system directories (/etc, /sys, /proc, /dev, /usr, /bin, /sbin, /boot, /var/run, /var/lib).",
-    })
-        .refine((value) => !value.split(/[/\\]/).some((segment) => segment === ".."), {
-        message: "Preparation path may not contain `..` segments.",
-    }),
-    about: z.string().min(1).optional(),
-    build_plan: BuildPlanIdSchema.optional(),
-    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
-    max_loops: SourceBuildMaxLoopsSchema.optional(),
-    checks: z.array(SourceReadinessCheckSchema).default([]),
-    requested_artifacts: z.array(RequestedArtifactSchema).optional(),
-    source_profile: SourceProfileSchema.optional(),
-}).strict();
-export const SourceFolderBindingSchema = z.object({
-    path: z.string().min(1),
-}).passthrough();
-export const VerifiableContextInterfConfigSchema = z.object({
-    type: z.literal("verifiable-context"),
-    name: PreparationNameSchema,
-    about: z.string().optional(),
-    build_plan: BuildPlanIdSchema,
-    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
-    max_loops: SourceBuildMaxLoopsSchema.optional(),
-    checks: z.array(SourceReadinessCheckSchema).default([]),
-    build_plan_origin: z.object({
-        selected: BuildPlanIdSchema,
-        local_draft: z.boolean().optional(),
-    }).optional(),
-    source: z.object({
-        path: z.string(),
-        control_path: z.string().optional(),
-        preparation_path: z.string().optional(),
-    }),
-}).passthrough();
-export const InterfConfigSchema = VerifiableContextInterfConfigSchema;
-export const SourceFolderConfigSchema = z.object({
-    source_folder: SourceFolderBindingSchema.optional(),
-    preparations: z.array(SourcePreparationConfigSchema).default([]),
-}).strict();

package/dist/packages/project/preparation-entries.d.ts

@@ -1,11 +0,0 @@
-import type { SourcePreparationConfig } from "./lib/schema.js";
-export interface SavedPreparationEntry {
-    config: SourcePreparationConfig;
-    path: string | null;
-    localDraft: boolean;
-}
-export declare function listSavedPreparationEntries(prepDataDir: string): SavedPreparationEntry[];
-export declare function findBuiltVerifiableContextPath(prepDataDir: string, preparationName: string): string | null;
-export declare function findSavedPreparationConfig(prepDataDir: string, preparationName: string): SourcePreparationConfig | null;
-export declare function createVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
-export declare function ensureVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;