@interf/compiler 0.6.1 → 0.6.3

package/dist/lib/source-config.js

@@ -1,293 +1,3 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
-import { readInterfConfig, refreshCompiledBootstrapGuidance, } from "./interf.js";
-import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { getCompiledWorkflow } from "./workflow-definitions.js";
-import { SourceFolderConfigSchema, } from "./schema.js";
-import { slugify } from "./util.js";
-import { assertPathWithinRoot } from "./util.js";
-import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "./compiled-paths.js";
-export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-function sourceConfigPath(sourcePath) {
-    return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
-}
-function normalizeTruthChecks(cases) {
-    const seen = new Set();
-    return cases.map((caseSpec, index) => {
-        const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
-        let id = baseId;
-        let suffix = 2;
-        while (seen.has(id)) {
-            id = `${baseId}-${suffix}`;
-            suffix += 1;
-        }
-        seen.add(id);
-        return {
-            id,
-            question: caseSpec.question.trim(),
-            ...(caseSpec.answer ? { answer: caseSpec.answer.trim() } : {}),
-            ...(caseSpec.strictness ? { strictness: caseSpec.strictness.trim() } : {}),
-            ...(caseSpec.expect ? { expect: caseSpec.expect } : {}),
-        };
-    });
-}
-export function fingerprintTruthChecks(checks) {
-    const normalized = checks.map((check) => ({
-        question: check.question.trim(),
-        ...(check.answer ? { answer: check.answer.trim() } : {}),
-        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
-        ...(check.expect ? { expect: check.expect } : {}),
-    }));
-    return createHash("sha256")
-        .update(JSON.stringify(normalized))
-        .digest("hex")
-        .slice(0, 16);
-}
-export function loadSourceFolderConfig(sourcePath) {
-    const filePath = sourceConfigPath(sourcePath);
-    if (!existsSync(filePath))
-        return null;
-    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
-}
-export function listSourceDatasetConfigs(config) {
-    return config?.datasets ?? [];
-}
-export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
-    const configured = override ?? datasetConfig.max_attempts ?? null;
-    if (configured == null)
-        return null;
-    const normalized = Math.trunc(configured);
-    if (!Number.isFinite(normalized) || normalized < 1)
-        return 1;
-    return Math.min(5, normalized);
-}
-export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
-    const configured = override ?? datasetConfig.max_loops ?? null;
-    if (configured == null)
-        return null;
-    const normalized = Math.trunc(configured);
-    if (!Number.isFinite(normalized) || normalized < 1)
-        return 1;
-    return Math.min(3, normalized);
-}
-export function getDefaultSourceDatasetConfig(config) {
-    const datasets = listSourceDatasetConfigs(config);
-    return datasets[0] ?? null;
-}
-export function findSourceDatasetConfig(config, datasetName) {
-    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
-}
-function toWritableSourceProjectConfig(config) {
-    const datasets = config?.datasets ?? [];
-    if (datasets.length > 0) {
-        return {
-            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
-        };
-    }
-    return {};
-}
-function toWritableSourceDatasetConfig(dataset) {
-    return {
-        name: dataset.name,
-        ...(dataset.path && dataset.path !== "." ? { path: dataset.path } : {}),
-        ...(dataset.about ? { about: dataset.about } : {}),
-        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
-        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
-        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
-        checks: dataset.checks,
-    };
-}
-export function saveSourceFolderConfig(sourcePath, config) {
-    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
-}
-export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
-    const existing = loadSourceFolderConfig(sourcePath);
-    const currentDataset = findSourceDatasetConfig(existing, datasetName);
-    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
-    const currentChecks = currentDataset?.checks ?? [];
-    const nextDataset = {
-        ...toWritableSourceDatasetConfig(currentDataset ?? {
-            name: datasetName,
-            path: ".",
-            checks: [],
-        }),
-        checks: [...currentChecks, ...checks],
-    };
-    saveSourceFolderConfig(sourcePath, {
-        datasets: [
-            nextDataset,
-            ...otherDatasets,
-        ],
-    });
-}
-export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
-    const existing = loadSourceFolderConfig(sourcePath);
-    const datasets = listSourceDatasetConfigs(existing);
-    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
-    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
-    if (existingIndex >= 0) {
-        datasets[existingIndex] = datasetConfig;
-    }
-    else {
-        datasets.push(datasetConfig);
-    }
-    saveSourceFolderConfig(sourcePath, {
-        datasets,
-    });
-}
-export function compiledMaxAttempts(maxAttempts) {
-    if (maxAttempts == null)
-        return undefined;
-    return resolveDatasetCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
-}
-export function compiledMaxLoops(maxLoops) {
-    if (maxLoops == null)
-        return undefined;
-    return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
-}
-export function sourceDatasetConfigFromInterfConfig(config, datasetPath = ".") {
-    return {
-        name: config.name,
-        path: datasetPath,
-        ...(config.about ? { about: config.about } : {}),
-        ...(config.workflow ? { workflow: config.workflow } : {}),
-        ...(typeof config.max_attempts === "number"
-            ? { max_attempts: config.max_attempts }
-            : {}),
-        ...(typeof config.max_loops === "number"
-            ? { max_loops: config.max_loops }
-            : {}),
-        checks: config.checks ?? [],
-    };
-}
-export function loadCompiledDatasetConfig(compiledPath) {
-    const config = readInterfConfig(compiledPath);
-    if (!config)
-        return null;
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
-        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled dataset source path")).split(sep).join("/") || "."
-        : ".";
-    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
-}
-export function saveCompiledInterfConfig(compiledPath, config) {
-    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
-    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
-    return config;
-}
-export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig) {
-    const current = readInterfConfig(compiledPath);
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const datasetAbsolutePath = resolve(projectPath, datasetConfig.path ?? ".");
-    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
-    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
-    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
-    const workflowOrigin = workflowChanged || !current?.workflow_origin
-        ? {
-            selected: workflowId,
-            local_draft: false,
-        }
-        : current.workflow_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
-    const nextConfig = {
-        ...passthrough,
-        ...(!current ? {
-            type: "compiled",
-            source: {
-                path: "./raw",
-            },
-        } : {}),
-        type: "compiled",
-        name: datasetConfig.name,
-        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
-        workflow: workflowId,
-        ...(typeof datasetConfig.max_attempts === "number"
-            ? { max_attempts: datasetConfig.max_attempts }
-            : {}),
-        ...(typeof datasetConfig.max_loops === "number"
-            ? { max_loops: datasetConfig.max_loops }
-            : {}),
-        checks: datasetConfig.checks,
-        workflow_origin: workflowOrigin,
-        source: {
-            path: current?.source?.path ?? "./raw",
-            control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: datasetRelativePath,
-        },
-    };
-    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
-    if (workflowChanged) {
-        const sourcePath = projectPath;
-        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-        seedCompiledWorkflowPackage({
-            compiledPath,
-            sourcePath,
-            workflowId: selectedWorkflow.id,
-        });
-    }
-    refreshCompiledBootstrapGuidance(compiledPath);
-    return saved;
-}
-function buildLoadedTestSpec(options) {
-    if (options.checks.length === 0)
-        return null;
-    const testId = options.id ?? slugify(options.name);
-    return {
-        id: options.targetType === "raw" ? `${testId}-raw` : testId,
-        filePath: options.filePath,
-        type: options.targetType,
-        name: options.name,
-        description: options.about ?? options.fallbackDescription,
-        cases: normalizeTruthChecks(options.checks),
-    };
-}
-export function buildTestSpecFromSourceFolderConfig(options) {
-    const { sourcePath, targetName, targetType = "compiled" } = options;
-    const config = loadSourceFolderConfig(sourcePath);
-    if (!config)
-        return null;
-    const datasets = listSourceDatasetConfigs(config);
-    if (datasets.length === 0)
-        return null;
-    const match = targetName
-        ? datasets.find((entry) => entry.name === targetName)
-        : datasets.length === 1
-            ? datasets[0]
-            : getDefaultSourceDatasetConfig(config);
-    if (!match)
-        return null;
-    const configPath = sourceConfigPath(sourcePath);
-    return buildLoadedTestSpec({
-        id: match.id,
-        name: match.name,
-        about: match.about,
-        checks: match.checks,
-        targetType,
-        filePath: targetType === "raw"
-            ? `${configPath}#datasets/${match.name}:file-as-is`
-            : `${configPath}#datasets/${match.name}:compiled`,
-        fallbackDescription: `Derived from dataset truth checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
-    });
-}
-export function buildTestSpecFromCompiledDatasetConfig(options) {
-    const { compiledPath, targetType = "compiled" } = options;
-    const config = readInterfConfig(compiledPath);
-    const configPath = compiledInterfConfigPath(compiledPath);
-    if (!config)
-        return null;
-    return buildLoadedTestSpec({
-        name: config.name,
-        about: config.about,
-        checks: config.checks ?? [],
-        targetType,
-        filePath: targetType === "raw"
-            ? `${configPath}#checks:file-as-is`
-            : `${configPath}#checks:compiled`,
-        fallbackDescription: "Derived from compiled-dataset truth checks.",
-    });
-}
-export function resolveSourceDatasetPath(projectPath, datasetConfig) {
-    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path ?? "."), "Dataset path");
-}
+// Compatibility shim for historical `src/lib/source-config.ts` imports.
+// Source of truth: `src/packages/project-model/source-config.ts`.
+export * from "../packages/project-model/source-config.js";

package/dist/lib/state-artifacts.d.ts

@@ -1,8 +1 @@
-import { type CompiledHealth, type CompiledRawSnapshot, type CompiledViewSpec } from "./schema.js";
-export declare function refreshCompiledArtifacts(dirPath: string, options?: {
-    ensureViewSpec?: boolean;
-}): {
-    health: CompiledHealth;
-    viewSpec?: CompiledViewSpec;
-    rawSnapshot: CompiledRawSnapshot;
-};
+export * from "../packages/compiler/state-artifacts.js";

package/dist/lib/state-artifacts.js

@@ -1,13 +1 @@
-import { saveCompiledHealth, } from "./state-io.js";
-import { computeCompiledHealth, } from "./state-health.js";
-import { ensureCompiledRawSnapshot, ensureCompiledViewSpec, } from "./state-view.js";
-export function refreshCompiledArtifacts(dirPath, options) {
-    const health = computeCompiledHealth(dirPath);
-    saveCompiledHealth(dirPath, health);
-    const rawSnapshot = ensureCompiledRawSnapshot(dirPath);
-    let viewSpec;
-    if (options?.ensureViewSpec) {
-        viewSpec = ensureCompiledViewSpec(dirPath);
-    }
-    return { health, viewSpec, rawSnapshot };
-}
+export * from "../packages/compiler/state-artifacts.js";

package/dist/lib/state-health.d.ts

@@ -1,4 +1 @@
-import { type CompiledHealth, type CompiledStage, type RuntimeStatus } from "./schema.js";
-export declare function computeCompiledHealth(dirPath: string): CompiledHealth;
-export declare function resolveCompiledStatus(..._args: unknown[]): RuntimeStatus;
-export declare function resolveCompiledStage(...args: unknown[]): CompiledStage;
+export * from "../packages/compiler/state-health.js";

package/dist/lib/state-health.js

@@ -1,132 +1 @@
-import { basename, join } from "node:path";
-import { existsSync } from "node:fs";
-import { readInterfConfig, resolveSourceFolderPath, } from "./interf.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { loadRuntimeRun } from "./runtime.js";
-import { loadState } from "./state-io.js";
-import { validateCompiled, validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
-import { listFilesRecursive } from "./filesystem.js";
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
-export function computeCompiledHealth(dirPath) {
-    const now = new Date().toISOString();
-    const config = readInterfConfig(dirPath);
-    const targetName = config?.name ?? basename(dirPath);
-    const sourcePath = config ? resolveSourceFolderPath(dirPath, config) : dirPath;
-    const sourceTotal = config ? discoverSourceFiles(sourcePath, dirPath).totalCount : 0;
-    const state = loadState(dirPath);
-    const validation = validateCompiled(dirPath);
-    const activeRun = loadRuntimeRun(dirPath);
-    const workflowId = config
-        ? resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`)
-        : null;
-    let workflow = null;
-    if (workflowId) {
-        try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
-        }
-        catch {
-            workflow = null;
-        }
-    }
-    const stageResults = workflow?.stages.map((stage) => ({
-        stage,
-        validation: validateCompiledStage(dirPath, stage.id),
-    })) ?? [];
-    const completedStages = stageResults.filter((entry) => entry.validation.ok).length;
-    const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
-    const workflowValidation = validateCompiledWorkflow(dirPath);
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
-    const zoneMetrics = Object.fromEntries((schema?.zones ?? []).map((zone) => [
-        `zone_${zone.id}`,
-        countZoneArtifacts(dirPath, zone.path, zone.kind),
-    ]));
-    let status = "idle";
-    let stage = "idle";
-    let summary = "Idle — no source files have been compiled yet.";
-    const errors = workflowValidation.errors.length;
-    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.workflow_valid || !validation.schema_valid) {
-        status = "failed";
-        stage = "failed";
-        summary = workflowValidation.summary;
-    }
-    else if (activeRun?.status === "running") {
-        status = "running";
-        stage = activeRun.stage;
-        summary = `Running — ${activeRun.stage_label} via ${activeRun.executor.display_name}. ${activeRun.summary}`;
-    }
-    else if (sourceTotal === 0 && completedStages === 0) {
-        status = "idle";
-        stage = "idle";
-        summary = "Idle — no source files have been compiled yet.";
-    }
-    else if (activeRun?.status === "failed") {
-        status = "failed";
-        stage = activeRun.stage;
-        summary = activeRun.error ?? activeRun.summary;
-    }
-    else if (workflowValidation.ok) {
-        status = "compiled";
-        stage = "compiled";
-        summary = `Compiled — ${completedStages}/${workflow?.stages.length ?? 0} workflow stages satisfied.`;
-    }
-    else {
-        status = "stale";
-        stage = firstFailed?.stage.id ?? "compiled";
-        summary = firstFailed?.validation.summary ?? workflowValidation.summary;
-    }
-    const checks = {
-        ...validation,
-        ...(workflow
-            ? Object.fromEntries(workflow.stages.map((workflowStage) => [
-                `stage_${workflowStage.id}_ok`,
-                stageResults.find((entry) => entry.stage.id === workflowStage.id)?.validation.ok ?? false,
-            ]))
-            : {}),
-    };
-    return {
-        kind: "compiled-health",
-        version: 2,
-        generated_at: now,
-        target_name: targetName,
-        status,
-        stage,
-        summary,
-        metrics: {
-            source_total: sourceTotal,
-            stage_total: workflow?.stages.length ?? 0,
-            completed_stages: completedStages,
-            warnings: state?.warning_count ?? 0,
-            errors: (state?.error_count ?? 0) + errors,
-            ...zoneMetrics,
-        },
-        checks,
-    };
-}
-export function resolveCompiledStatus(..._args) {
-    const state = _args[_args.length - 1];
-    if (state?.error_count && state.error_count > 0)
-        return "failed";
-    if (!state?.stages || Object.keys(state.stages).length === 0)
-        return "idle";
-    const allSucceeded = Object.values(state.stages).every((stage) => stage.status === "succeeded");
-    return allSucceeded ? "compiled" : "stale";
-}
-export function resolveCompiledStage(...args) {
-    const state = args[0];
-    if (state?.error_count && state.error_count > 0)
-        return "failed";
-    if (!state?.stages || Object.keys(state.stages).length === 0)
-        return "idle";
-    const failedStage = Object.entries(state.stages).find(([, stage]) => stage.status !== "succeeded");
-    return failedStage?.[0] ?? "compiled";
-}
+export * from "../packages/compiler/state-health.js";

package/dist/lib/state-io.d.ts

@@ -1,10 +1 @@
-import { type CompiledHealth, type CompiledRawSnapshot, type CompiledState, type CompiledViewSpec } from "./schema.js";
-export declare function loadState<T>(dirPath: string): T | null;
-export declare function saveState<T>(dirPath: string, state: T): void;
-export declare function loadCompiledHealth(dirPath: string): CompiledHealth | null;
-export declare function saveCompiledHealth(dirPath: string, health: CompiledHealth): void;
-export declare function loadCompiledViewSpec(dirPath: string): CompiledViewSpec | null;
-export declare function saveCompiledViewSpec(dirPath: string, viewSpec: CompiledViewSpec): void;
-export declare function loadCompiledRawSnapshot(dirPath: string): CompiledRawSnapshot | null;
-export declare function saveEmptyCompiledInventory(dirPath: string): void;
-export declare function initCompiledState(): CompiledState;
+export * from "../packages/compiler/state-io.js";

package/dist/lib/state-io.js

@@ -1,76 +1 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { warnInterf } from "./logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { CompiledHealthSchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./schema.js";
-import { emptyCompiledInventory, } from "./runtime-inventory.js";
-import { healthPath, rawSnapshotPath, statePath, viewSpecPath } from "./state-paths.js";
-import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
-export function loadState(dirPath) {
-    const path = statePath(dirPath);
-    if (!existsSync(path))
-        return null;
-    const raw = readJsonFileUnchecked(path, "runtime state");
-    if (raw === null)
-        return null;
-    const parsed = CompiledStateSchema.safeParse(raw);
-    if (parsed.success) {
-        return parsed.data;
-    }
-    warnInterf(`Warning: failed to validate runtime state at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-    return null;
-}
-export function saveState(dirPath, state) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(statePath(dirPath), JSON.stringify(state, null, 2) + "\n");
-}
-export function loadCompiledHealth(dirPath) {
-    const path = healthPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return readJsonFileWithSchema(path, "compiled health", CompiledHealthSchema);
-}
-export function saveCompiledHealth(dirPath, health) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(healthPath(dirPath), JSON.stringify(health, null, 2) + "\n");
-}
-export function loadCompiledViewSpec(dirPath) {
-    const path = viewSpecPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return loadViewSpec(path, CompiledViewSpecSchema);
-}
-export function saveCompiledViewSpec(dirPath, viewSpec) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(viewSpecPath(dirPath), JSON.stringify(viewSpec, null, 2) + "\n");
-}
-export function loadCompiledRawSnapshot(dirPath) {
-    const path = rawSnapshotPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return readJsonFileWithSchema(path, "compiled raw snapshot", CompiledRawSnapshotSchema);
-}
-export function saveEmptyCompiledInventory(dirPath) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(compiledRuntimeInventoryPath(dirPath), JSON.stringify(emptyCompiledInventory(), null, 2) + "\n");
-}
-export function initCompiledState() {
-    return {
-        version: 2,
-        pending: [],
-        stages: {},
-        last_add: null,
-        last_compile: null,
-        warning_count: 0,
-        error_count: 0,
-    };
-}
-function loadViewSpec(filePath, schema) {
-    try {
-        const raw = JSON.parse(readFileSync(filePath, "utf8"));
-        const parsed = schema.safeParse(raw);
-        return parsed.success ? parsed.data ?? null : null;
-    }
-    catch {
-        return null;
-    }
-}
+export * from "../packages/compiler/state-io.js";

package/dist/lib/state-paths.d.ts

@@ -1,4 +1 @@
-export declare function statePath(dirPath: string): string;
-export declare function healthPath(dirPath: string): string;
-export declare function viewSpecPath(dirPath: string): string;
-export declare function rawSnapshotPath(dirPath: string): string;
+export * from "../packages/compiler/state-paths.js";

package/dist/lib/state-paths.js

@@ -1,13 +1 @@
-import { compiledRawSnapshotMetadataPath, compiledRuntimeHealthPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "./compiled-paths.js";
-export function statePath(dirPath) {
-    return compiledRuntimeStatePath(dirPath);
-}
-export function healthPath(dirPath) {
-    return compiledRuntimeHealthPath(dirPath);
-}
-export function viewSpecPath(dirPath) {
-    return compiledRuntimeViewSpecPath(dirPath);
-}
-export function rawSnapshotPath(dirPath) {
-    return compiledRawSnapshotMetadataPath(dirPath);
-}
+export * from "../packages/compiler/state-paths.js";

package/dist/lib/state-view.d.ts

@@ -1,4 +1 @@
-import { type CompiledRawSnapshot, type CompiledViewSpec } from "./schema.js";
-export declare function ensureCompiledViewSpec(dirPath: string): CompiledViewSpec;
-export declare function ensureCompiledRawSnapshot(dirPath: string): CompiledRawSnapshot;
-export declare function normalizeCompiledViewSpec(existing: CompiledViewSpec, defaults?: CompiledViewSpec): CompiledViewSpec;
+export * from "../packages/compiler/state-view.js";