@sxl-studio/token-transformer 1.0.0 → 2.0.0

package/dist/core/writer.js

@@ -1,124 +1,578 @@
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
-import { loadTokens, groupTokensByFile } from "./loader.js";
-import { transformCSS } from "../transformers/css.js";
-import { transformSwiftUI } from "../transformers/swiftui.js";
-import { transformKotlin } from "../transformers/kotlin.js";
-export async function runTransform(config) {
-    const { tokens, collections, errors: loadErrors } = await loadTokens(config);
-    const results = [];
-    for (const [platform, platformConfig] of Object.entries(config.platforms)) {
-        if (!platformConfig)
-            continue;
-        const result = {
-            platform,
+import { minimatch } from "minimatch";
+import { shouldSkipByType } from "./token-types.js";
+import { applyTokenFilter } from "../emit/shared.js";
+import { emitCss } from "../emit/css.js";
+import { emitSwift } from "../emit/swift.js";
+import { emitKotlin } from "../emit/kotlin.js";
+import { emitXml } from "../emit/xml.js";
+import { loadTokenSets, scanSourceFiles } from "./token-loader.js";
+import { resolveTokens } from "./resolver.js";
+import { buildOutputStateEntries, computeContentHash, computeConfigHash, createTransformState, diffSourceFiles, } from "./incremental.js";
+export async function runTransform(config, runOptions = {}) {
+    const diagnostics = [];
+    const mode = runOptions.mode ?? "smart";
+    const previousState = runOptions.previousState ?? null;
+    const configHash = runOptions.configHash ?? computeConfigHash(config);
+    const allOutputIds = config.outputs.map((output) => output.id);
+    const scannedSourceFiles = await scanSourceFiles(config.source.tokenDir, config.source.include, config.source.exclude);
+    const configChanged = !previousState || previousState.configHash !== configHash;
+    const sourceDiff = previousState
+        ? diffSourceFiles(previousState.sourceFiles, scannedSourceFiles)
+        : {
+            changed: new Set(Object.keys(scannedSourceFiles)),
+            removed: new Set(),
+        };
+    const missingOutputIds = !modeIsForce(mode) && previousState
+        ? await detectMissingOutputIds(previousState.outputs)
+        : new Set();
+    const fullRebuild = mode === "force" || !previousState || configChanged;
+    const fullReason = mode === "force"
+        ? "force mode"
+        : !previousState
+            ? "missing previous state"
+            : configChanged
+                ? "config changed"
+                : "source changes";
+    if (!fullRebuild &&
+        sourceDiff.changed.size === 0 &&
+        sourceDiff.removed.size === 0 &&
+        missingOutputIds.size === 0 &&
+        previousState) {
+        const state = createTransformState({
+            configHash,
+            sourceFiles: scannedSourceFiles,
+            outputs: previousState.outputs,
+        });
+        return {
             files: [],
-            tokenCount: 0,
-            errors: [...loadErrors],
+            removedFiles: [],
+            diagnostics,
+            tokenSets: [],
+            state,
+            meta: {
+                mode,
+                fullRebuild: false,
+                reason: "no source changes",
+                changedSourceFiles: [],
+                removedSourceFiles: [],
+                affectedTokenSets: [],
+                affectedOutputIds: [],
+                skippedOutputCount: allOutputIds.length,
+            },
         };
-        try {
-            if (platformConfig.fileMapping && platformConfig.fileMapping.length > 0) {
-                result.files = buildMappedFiles(tokens, collections, platformConfig, platform);
+    }
+    const loaded = await loadTokenSets(config);
+    diagnostics.push(...loaded.diagnostics);
+    const changedFiles = fullRebuild
+        ? new Set(Object.keys(loaded.sourceFiles))
+        : sourceDiff.changed;
+    const removedFiles = fullRebuild
+        ? new Set(Object.keys(previousState?.sourceFiles ?? {}).filter((filePath) => !(filePath in loaded.sourceFiles)))
+        : sourceDiff.removed;
+    const affectedTokenSets = new Set();
+    if (fullRebuild) {
+        for (const tokenSet of loaded.tokenSets)
+            affectedTokenSets.add(tokenSet.id);
+    }
+    else {
+        for (const tokenSet of loaded.tokenSets) {
+            const files = collectTokenSetSourceFiles(tokenSet);
+            if (intersects(files, changedFiles) || intersects(files, removedFiles)) {
+                affectedTokenSets.add(tokenSet.id);
+            }
+        }
+    }
+    const affectedOutputIds = resolveAffectedOutputIds(config, affectedTokenSets, changedFiles, removedFiles, missingOutputIds, previousState, fullRebuild);
+    const shouldProcessOutput = (outputId) => {
+        if (fullRebuild)
+            return true;
+        return affectedOutputIds.has(outputId);
+    };
+    const tokenSetIdsToResolve = new Set();
+    if (fullRebuild) {
+        for (const tokenSet of loaded.tokenSets)
+            tokenSetIdsToResolve.add(tokenSet.id);
+    }
+    else {
+        for (const output of config.outputs) {
+            if (!shouldProcessOutput(output.id))
+                continue;
+            for (const mapping of output.files)
+                tokenSetIdsToResolve.add(mapping.tokenSet);
+        }
+    }
+    const resolvedTokenSets = loaded.tokenSets.map((tokenSet) => {
+        if (!tokenSetIdsToResolve.has(tokenSet.id)) {
+            return tokenSet;
+        }
+        const cleanTokens = filterUnsupportedTokens(tokenSet.tokens, config, diagnostics, tokenSet.id);
+        const resolverScope = tokenSet.resolverTokens.length > 0 ? tokenSet.resolverTokens : tokenSet.tokens;
+        const resolved = resolveTokens(cleanTokens, {
+            remBase: config.options.remBase,
+            maxDepth: config.options.maxAliasDepth,
+            unresolvedAlias: tokenSet.unresolvedAliases,
+            autoFixAliasSyntax: runOptions.autoFixAliasSyntax ?? false,
+            skipTokensWithIssues: runOptions.skipTokensWithIssues ?? false,
+        }, {
+            lookupTokens: resolverScope,
+        });
+        diagnostics.push(...resolved.diagnostics);
+        return {
+            ...tokenSet,
+            tokens: resolved.tokens,
+        };
+    });
+    const tokenSetMap = new Map(resolvedTokenSets.map((item) => [item.id, item]));
+    const generatedFiles = [];
+    for (const output of config.outputs) {
+        if (!shouldProcessOutput(output.id))
+            continue;
+        for (const mapping of output.files) {
+            const tokenSet = tokenSetMap.get(mapping.tokenSet);
+            if (!tokenSet) {
+                diagnostics.push({
+                    level: "error",
+                    code: "OUTPUT_TOKEN_SET_MISSING",
+                    message: `Output "${output.id}" references missing tokenSet "${mapping.tokenSet}"`,
+                    outputId: output.id,
+                });
+                continue;
+            }
+            const filtered = applyTokenFilter(tokenSet.tokens, mapping.filter);
+            if (filtered.length === 0)
+                continue;
+            if (mapping.splitBySourceFile) {
+                const grouped = groupTokensBySourceFile(filtered, mapping.splitBySourceFile.include, mapping.splitBySourceFile.exclude);
+                if (grouped.size === 0) {
+                    diagnostics.push({
+                        level: "warn",
+                        code: "SPLIT_BY_SOURCE_EMPTY",
+                        message: `Output "${output.id}" splitBySourceFile produced no groups for tokenSet "${mapping.tokenSet}"`,
+                        outputId: output.id,
+                    });
+                    continue;
+                }
+                for (const [sourceFile, sourceTokens] of grouped) {
+                    const context = buildSplitContext(sourceFile);
+                    const renderedOutput = renderTemplate(mapping.splitBySourceFile.outputPattern, context);
+                    if (renderedOutput.missing.length > 0) {
+                        diagnostics.push({
+                            level: "error",
+                            code: "SPLIT_TEMPLATE_MISSING_FIELD",
+                            message: `Output "${output.id}" has unknown placeholders in split outputPattern: ` +
+                                renderedOutput.missing.join(", "),
+                            outputId: output.id,
+                        });
+                        continue;
+                    }
+                    const relativeOutputRaw = mapping.output
+                        ? path.posix.join(mapping.output, renderedOutput.value)
+                        : renderedOutput.value;
+                    const relativeOutput = normalizeRelativeOutput(relativeOutputRaw);
+                    if (!relativeOutput) {
+                        diagnostics.push({
+                            level: "error",
+                            code: "SPLIT_OUTPUT_PATH_INVALID",
+                            message: `Output "${output.id}" resolved invalid split output path "${relativeOutputRaw}"`,
+                            outputId: output.id,
+                        });
+                        continue;
+                    }
+                    const splitPrefix = resolveSplitPrefix(mapping, context, diagnostics, output.id);
+                    const prefix = resolveOutputPrefix(output, mapping, splitPrefix);
+                    emitMappingFiles(output, relativeOutput, sourceTokens, prefix, config, diagnostics, generatedFiles, mapping.tokenSet);
+                }
+                continue;
             }
-            else {
-                result.files = buildAutoFiles(tokens, collections, platformConfig, platform);
+            if (!mapping.output) {
+                diagnostics.push({
+                    level: "error",
+                    code: "OUTPUT_MAPPING_MISSING_OUTPUT",
+                    message: `Output "${output.id}" mapping for tokenSet "${mapping.tokenSet}" has no output path`,
+                    outputId: output.id,
+                });
+                continue;
             }
-            result.tokenCount = result.files.reduce((sum, f) => sum + f.tokenCount, 0);
+            const relativeOutput = normalizeRelativeOutput(mapping.output);
+            if (!relativeOutput) {
+                diagnostics.push({
+                    level: "error",
+                    code: "OUTPUT_PATH_INVALID",
+                    message: `Output "${output.id}" has invalid output path "${mapping.output}"`,
+                    outputId: output.id,
+                });
+                continue;
+            }
+            const prefix = resolveOutputPrefix(output, mapping);
+            emitMappingFiles(output, relativeOutput, filtered, prefix, config, diagnostics, generatedFiles, mapping.tokenSet);
         }
-        catch (err) {
-            result.errors.push(`Transform error (${platform}): ${err}`);
+    }
+    const generatedEntries = buildOutputStateEntries(generatedFiles);
+    const staleOutputFiles = collectStaleOutputFiles(previousState, generatedEntries, affectedOutputIds, fullRebuild);
+    const filesToWrite = filterFilesToWrite(generatedFiles, fullRebuild ? null : previousState, missingOutputIds);
+    const mergedOutputState = mergeOutputState(previousState, generatedEntries, affectedOutputIds, fullRebuild);
+    const state = createTransformState({
+        configHash,
+        sourceFiles: loaded.sourceFiles,
+        outputs: mergedOutputState,
+    });
+    return {
+        files: filesToWrite,
+        removedFiles: staleOutputFiles,
+        diagnostics,
+        tokenSets: resolvedTokenSets,
+        state,
+        meta: {
+            mode,
+            fullRebuild,
+            reason: fullRebuild ? fullReason : "affected outputs only",
+            changedSourceFiles: [...changedFiles].sort(),
+            removedSourceFiles: [...removedFiles].sort(),
+            affectedTokenSets: [...affectedTokenSets].sort(),
+            affectedOutputIds: [...affectedOutputIds].sort(),
+            skippedOutputCount: config.outputs.filter((output) => !shouldProcessOutput(output.id)).length,
+        },
+    };
+}
+export async function writeOutputFiles(files, removedFiles = []) {
+    const diagnostics = [];
+    let written = 0;
+    let removed = 0;
+    for (const filePath of [...new Set(removedFiles)]) {
+        try {
+            await fs.rm(filePath, { force: true });
+            removed += 1;
+        }
+        catch (error) {
+            diagnostics.push({
+                level: "error",
+                code: "OUTPUT_REMOVE_ERROR",
+                message: `Failed to remove stale output ${filePath}: ${String(error)}`,
+            });
+        }
+    }
+    for (const file of files) {
+        try {
+            await fs.mkdir(path.dirname(file.path), { recursive: true });
+            await fs.writeFile(file.path, file.content, "utf-8");
+            written += 1;
+        }
+        catch (error) {
+            diagnostics.push({
+                level: "error",
+                code: "OUTPUT_WRITE_ERROR",
+                message: `Failed to write ${file.path}: ${String(error)}`,
+            });
         }
-        results.push(result);
     }
-    return results;
+    return { written, removed, diagnostics };
 }
-function buildMappedFiles(allTokens, _collections, config, platform) {
-    const files = [];
-    for (const mapping of config.fileMapping) {
-        const filtered = filterTokens(allTokens, mapping);
-        if (filtered.length === 0)
-            continue;
-        const content = transformTokens(filtered, config, platform, allTokens);
+function defaultResolveAliases(platform) {
+    return platform !== "css";
+}
+function resolveOutputPrefix(output, mapping, splitPrefix) {
+    if (Object.prototype.hasOwnProperty.call(mapping, "prefix")) {
+        return mapping.prefix ?? undefined;
+    }
+    if (splitPrefix !== undefined)
+        return splitPrefix;
+    return output.prefix ?? undefined;
+}
+function emitMappingFiles(output, relativeOutput, tokens, prefix, config, diagnostics, files, tokenSetId) {
+    const emitInput = {
+        tokens,
+        platform: output.platform,
+        prefix,
+        resolveAliases: output.resolveAliases ?? defaultResolveAliases(output.platform),
+        splitEffects: output.splitEffects ?? true,
+        showDescriptions: output.showDescriptions ?? true,
+        collisions: config.options.collisionStrategy,
+        outputId: output.id,
+        remBase: config.options.remBase,
+    };
+    const sourceFiles = collectTokenSourceFiles(tokens);
+    if (output.platform === "css") {
+        const emitted = emitCss(emitInput);
+        diagnostics.push(...emitted.diagnostics);
         files.push({
-            path: path.join(config.outputDir, mapping.output),
-            content,
-            tokenCount: filtered.length,
+            path: path.join(output.outputDir, relativeOutput),
+            content: emitted.content,
+            tokenCount: tokens.length,
+            outputId: output.id,
+            tokenSetId,
+            sourceFiles,
         });
+        return;
     }
-    return files;
-}
-function buildAutoFiles(allTokens, collections, config, platform) {
-    const files = [];
-    const groups = groupTokensByFile(allTokens, collections);
-    const ext = platformExtension(platform);
-    for (const [groupKey, tokens] of groups) {
-        const sanitized = groupKey
-            .replace(/\.json$/, "")
-            .replace(/[/\\]/g, path.sep);
-        const filePath = path.join(config.outputDir, `${sanitized}${ext}`);
-        const content = transformTokens(tokens, config, platform, allTokens);
+    if (output.platform === "swift") {
+        const emitted = emitSwift(emitInput);
+        diagnostics.push(...emitted.diagnostics);
+        files.push({
+            path: path.join(output.outputDir, relativeOutput),
+            content: emitted.content,
+            tokenCount: tokens.length,
+            outputId: output.id,
+            tokenSetId,
+            sourceFiles,
+        });
+        return;
+    }
+    if (output.platform === "kotlin") {
+        const emitted = emitKotlin(emitInput);
+        diagnostics.push(...emitted.diagnostics);
         files.push({
-            path: filePath,
-            content,
+            path: path.join(output.outputDir, relativeOutput),
+            content: emitted.content,
             tokenCount: tokens.length,
+            outputId: output.id,
+            tokenSetId,
+            sourceFiles,
         });
+        return;
+    }
+    const emitted = emitXml(emitInput, relativeOutput);
+    diagnostics.push(...emitted.diagnostics);
+    const xmlFiles = emitted.extraFiles ?? [];
+    for (const xmlFile of xmlFiles) {
+        files.push({
+            path: path.join(output.outputDir, xmlFile.relativePath),
+            content: xmlFile.content,
+            tokenCount: xmlFile.tokenCount ?? tokens.length,
+            outputId: output.id,
+            tokenSetId,
+            sourceFiles,
+        });
+    }
+}
+function groupTokensBySourceFile(tokens, include, exclude) {
+    const grouped = new Map();
+    for (const token of tokens) {
+        const sourceFile = normalizeSourceFile(token.sourceFile);
+        const included = include.length === 0 || include.some((pattern) => minimatch(sourceFile, pattern, { dot: true }));
+        const excluded = exclude.some((pattern) => minimatch(sourceFile, pattern, { dot: true }));
+        if (!included || excluded)
+            continue;
+        const list = grouped.get(sourceFile) ?? [];
+        list.push(token);
+        grouped.set(sourceFile, list);
+    }
+    return new Map([...grouped.entries()].sort(([a], [b]) => a.localeCompare(b)));
+}
+function normalizeSourceFile(filePath) {
+    return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function buildSplitContext(sourceFile) {
+    const normalized = normalizeSourceFile(sourceFile);
+    const sourceDir = path.posix.dirname(normalized);
+    const sourceBase = path.posix.basename(normalized);
+    const sourceName = sourceBase.replace(/\.[^.]+$/u, "");
+    const sourceStem = sourceName.replace(/\.style$/iu, "");
+    const segments = normalized.split("/").filter(Boolean);
+    const componentsIndex = segments.indexOf("components");
+    const component = componentsIndex >= 0 && segments.length > componentsIndex + 1
+        ? segments[componentsIndex + 1]
+        : sourceStem;
+    return {
+        sourceFile: normalized,
+        sourceDir: sourceDir === "." ? "" : sourceDir,
+        sourceBase,
+        sourceName,
+        sourceStem,
+        component,
+        fileName: sourceStem,
+    };
+}
+function resolveSplitPrefix(mapping, context, diagnostics, outputId) {
+    if (!mapping.splitBySourceFile?.prefixPattern)
+        return undefined;
+    const rendered = renderTemplate(mapping.splitBySourceFile.prefixPattern, context);
+    if (rendered.missing.length > 0) {
+        diagnostics.push({
+            level: "error",
+            code: "SPLIT_PREFIX_TEMPLATE_MISSING_FIELD",
+            message: `Output "${outputId}" has unknown placeholders in split prefixPattern: ` +
+                rendered.missing.join(", "),
+            outputId,
+        });
+        return undefined;
+    }
+    const value = rendered.value.trim();
+    return value.length > 0 ? value : undefined;
+}
+function renderTemplate(template, context) {
+    const missing = new Set();
+    const value = template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_full, rawKey) => {
+        const key = rawKey.trim();
+        if (!(key in context)) {
+            missing.add(key);
+            return "";
+        }
+        return context[key];
+    });
+    return {
+        value,
+        missing: [...missing],
+    };
+}
+function normalizeRelativeOutput(value) {
+    const normalized = path.posix.normalize(value.replace(/\\/g, "/")).replace(/^(\.\/)+/, "");
+    if (!normalized || normalized === "." || path.posix.isAbsolute(normalized))
+        return null;
+    if (normalized.split("/").some((segment) => segment === ".."))
+        return null;
+    return normalized;
+}
+function filterUnsupportedTokens(tokens, config, diagnostics, tokenSetId) {
+    const kept = [];
+    for (const token of tokens) {
+        const normalized = token.type.trim();
+        const hasExplicitRule = config.options.unsupportedTypes.types[normalized] !== undefined ||
+            config.options.unsupportedTypes.types[normalized.toLowerCase()] !== undefined;
+        const action = config.options.unsupportedTypes.types[normalized] ??
+            config.options.unsupportedTypes.types[normalized.toLowerCase()] ??
+            config.options.unsupportedTypes.default;
+        const implicitSkip = shouldSkipByType(normalized) && !hasExplicitRule;
+        if (implicitSkip || (hasExplicitRule && action === "skip")) {
+            if (action === "warn") {
+                diagnostics.push({
+                    level: "warn",
+                    code: "UNSUPPORTED_TOKEN_TYPE",
+                    message: `Skipped token type ${normalized} in tokenSet ${tokenSetId}`,
+                    tokenPath: token.path,
+                });
+            }
+            continue;
+        }
+        if (hasExplicitRule && action === "error") {
+            diagnostics.push({
+                level: "error",
+                code: "UNSUPPORTED_TOKEN_TYPE",
+                message: `Blocked token type ${normalized} in tokenSet ${tokenSetId}`,
+                tokenPath: token.path,
+            });
+            continue;
+        }
+        kept.push(token);
+    }
+    return kept;
+}
+function collectTokenSourceFiles(tokens) {
+    return [...new Set(tokens.map((token) => normalizeSourceFile(token.sourceFile)))].sort();
+}
+function collectTokenSetSourceFiles(tokenSet) {
+    const files = new Set();
+    for (const selector of tokenSet.selectors) {
+        for (const filePath of selector.files)
+            files.add(normalizeSourceFile(filePath));
+        for (const filePath of selector.resolverFiles)
+            files.add(normalizeSourceFile(filePath));
     }
     return files;
 }
-function filterTokens(tokens, mapping) {
-    let filtered = tokens;
-    if (mapping.sources.length > 0) {
-        filtered = filtered.filter(t => mapping.sources.some(s => {
-            if (s.includes("*")) {
-                const regex = new RegExp("^" + s.replace(/\*/g, ".*") + "$");
-                return regex.test(t.sourceFile || "");
+function intersects(left, right) {
+    if (left.size === 0 || right.size === 0)
+        return false;
+    const [small, large] = left.size <= right.size ? [left, right] : [right, left];
+    for (const value of small) {
+        if (large.has(value))
+            return true;
+    }
+    return false;
+}
+function resolveAffectedOutputIds(config, affectedTokenSets, changedFiles, removedFiles, missingOutputIds, previousState, fullRebuild) {
+    const affected = new Set();
+    if (fullRebuild) {
+        for (const output of config.outputs)
+            affected.add(output.id);
+        return affected;
+    }
+    for (const output of config.outputs) {
+        for (const mapping of output.files) {
+            if (affectedTokenSets.has(mapping.tokenSet)) {
+                affected.add(output.id);
+                break;
             }
-            return (t.sourceFile || "") === s;
-        }));
+        }
+    }
+    if (!previousState)
+        return affected;
+    for (const outputId of missingOutputIds) {
+        affected.add(outputId);
     }
-    if (mapping.filter) {
-        if (mapping.filter.types && mapping.filter.types.length > 0) {
-            filtered = filtered.filter(t => mapping.filter.types.includes(t.type));
+    for (const item of Object.values(previousState.outputs)) {
+        const sourceSet = new Set(item.sourceFiles.map((filePath) => normalizeSourceFile(filePath)));
+        if (intersects(sourceSet, changedFiles) || intersects(sourceSet, removedFiles)) {
+            affected.add(item.outputId);
         }
-        if (mapping.filter.paths && mapping.filter.paths.length > 0) {
-            filtered = filtered.filter(t => mapping.filter.paths.some(p => t.path.startsWith(p)));
+    }
+    return affected;
+}
+function modeIsForce(mode) {
+    return mode === "force";
+}
+async function detectMissingOutputIds(outputs) {
+    const missing = new Set();
+    for (const item of Object.values(outputs)) {
+        try {
+            await fs.stat(item.path);
         }
-        if (mapping.filter.excludePaths && mapping.filter.excludePaths.length > 0) {
-            filtered = filtered.filter(t => !mapping.filter.excludePaths.some(p => t.path.startsWith(p)));
+        catch {
+            missing.add(item.outputId);
         }
     }
-    return filtered;
+    return missing;
 }
-function transformTokens(tokens, config, platform, allTokens) {
-    switch (platform) {
-        case "css": return transformCSS(tokens, config);
-        case "swiftui": return transformSwiftUI(tokens, config, allTokens);
-        case "kotlin": return transformKotlin(tokens, config, allTokens);
+function collectStaleOutputFiles(previousState, generatedEntries, affectedOutputIds, fullRebuild) {
+    if (!previousState)
+        return [];
+    const stale = [];
+    for (const [filePath, state] of Object.entries(previousState.outputs)) {
+        const shouldCheck = fullRebuild || affectedOutputIds.has(state.outputId);
+        if (!shouldCheck)
+            continue;
+        if (generatedEntries[filePath])
+            continue;
+        stale.push(filePath);
     }
+    return stale.sort();
 }
-function platformExtension(platform) {
-    switch (platform) {
-        case "css": return ".css";
-        case "swiftui": return ".swift";
-        case "kotlin": return ".kt";
+function mergeOutputState(previousState, generatedEntries, affectedOutputIds, fullRebuild) {
+    if (!previousState || fullRebuild) {
+        return generatedEntries;
     }
+    const next = {};
+    for (const [filePath, state] of Object.entries(previousState.outputs)) {
+        if (affectedOutputIds.has(state.outputId))
+            continue;
+        next[filePath] = state;
+    }
+    for (const [filePath, state] of Object.entries(generatedEntries)) {
+        next[filePath] = state;
+    }
+    return next;
 }
-export function writeOutputFiles(results) {
-    let written = 0;
-    const errors = [];
-    for (const result of results) {
-        for (const file of result.files) {
-            try {
-                const dir = path.dirname(file.path);
-                fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(file.path, file.content, "utf-8");
-                written++;
-            }
-            catch (err) {
-                errors.push(`Failed to write ${file.path}: ${err}`);
-            }
+function filterFilesToWrite(files, previousState, missingOutputIds) {
+    if (!previousState)
+        return files;
+    const filtered = [];
+    const previousEntries = previousState.outputs;
+    for (const file of files) {
+        if (file.outputId && missingOutputIds.has(file.outputId)) {
+            filtered.push(file);
+            continue;
+        }
+        const previous = previousEntries[file.path];
+        if (!previous) {
+            filtered.push(file);
+            continue;
+        }
+        const nextHash = computeContentHash(file.content);
+        if (previous.contentHash !== nextHash) {
+            filtered.push(file);
         }
     }
-    return { written, errors };
+    return filtered;
 }
 //# sourceMappingURL=writer.js.map