modwright 0.1.0

package/dist/core/build/steps/bg3.js

@@ -0,0 +1,129 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { walk } from "../../fsutil.js";
+import { assertAbsolute, runTool } from "../../toolchain/run.js";
+import { globToRegExp } from "../../validate/context.js";
+import { fileEntry } from "../manifest.js";
+import { resolvedToolNote, resolveOutDirPath, resolveSourceOrStagePath, resolveStageId } from "../paths.js";
+import { applyListingRules } from "./listing.js";
+import { BuildStepError } from "../types.js";
+export const DIVINE_TOOL_VERSION = "unknown (ExportTool zip name only)";
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+async function convertGlob(step, ctx, action, destExt, deleteSource) {
+    const inDir = resolveStageId(step.in, ctx);
+    const location = await ctx.locateTool("divine");
+    const re = globToRegExp(step.glob);
+    const walked = await walk(inDir, { limit: 200_000 });
+    const matches = walked.files.filter((f) => re.test(toPosix(f)));
+    if (matches.length === 0) {
+        throw new BuildStepError(`${step.step}: no files matched "${step.glob}" under ${inDir}`, step.id, step.step);
+    }
+    const inputs = [];
+    const outputs = [];
+    for (const rel of matches) {
+        const absIn = path.join(inDir, rel);
+        const absOut = absIn.replace(/\.[^./\\]+$/, destExt);
+        assertAbsolute([absIn, absOut]);
+        const args = ["-g", "bg3", "-a", action, "-s", absIn, "-d", absOut];
+        const result = await runTool(location, { args, expectOutputs: [absOut], requireFreshOutputs: true });
+        if (!result.ok) {
+            throw new BuildStepError(`${step.step} failed on ${rel}: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+        }
+        inputs.push(await fileEntry(absIn));
+        outputs.push(await fileEntry(absOut));
+        if (deleteSource)
+            await fs.unlink(absIn);
+    }
+    return { inputs, outputs };
+}
+export async function runDivineLsxToLsfStep(step, ctx) {
+    const inDir = resolveStageId(step.in, ctx);
+    if (ctx.mode === "dry-run") {
+        return {
+            inputs: [],
+            outputs: [],
+            verified: true,
+            plan: `divine convert-resource under ${inDir} (glob ${step.glob})` +
+                (step.deleteSource ? ", removing each staged .lsx once its .lsf is written" : ""),
+        };
+    }
+    const deleteSource = step.deleteSource ?? false;
+    const { inputs, outputs } = await convertGlob(step, ctx, "convert-resource", ".lsf", deleteSource);
+    return {
+        inputs,
+        outputs,
+        verified: true,
+        tool: "divine",
+        toolVersion: DIVINE_TOOL_VERSION,
+        extras: { fileCount: outputs.length, deletedSources: deleteSource ? outputs.length : 0 },
+    };
+}
+export async function runDivineLocaStep(step, ctx) {
+    const inDir = resolveStageId(step.in, ctx);
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `divine convert-loca under ${inDir} (glob ${step.glob})` };
+    }
+    const { inputs, outputs } = await convertGlob(step, ctx, "convert-loca", ".loca", false);
+    return { inputs, outputs, verified: true, tool: "divine", toolVersion: DIVINE_TOOL_VERSION, extras: { fileCount: outputs.length } };
+}
+export async function runDivineCreatePackageStep(step, ctx) {
+    const from = resolveSourceOrStagePath(step.from, ctx);
+    const out = resolveOutDirPath(step.out, ctx);
+    const dotSegment = from.split(/[\\/]/).find((seg) => seg.startsWith(".") && seg !== "." && seg !== "..");
+    if (dotSegment) {
+        throw new BuildStepError(`divine-create-package: the source path ${from} contains a dot-prefixed directory ("${dotSegment}"); ` +
+            `Divine silently produces an empty package from such paths. Set build.staging in modwright.json to a ` +
+            `path without dot-prefixed segments (for example "build/stage") and gitignore it.`, step.id, step.step);
+    }
+    const location = await ctx.locateTool("divine");
+    const args = ["-g", "bg3", "-a", "create-package", "-s", from, "-d", out];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `divine ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    assertAbsolute([from, out]);
+    const result = await runTool(location, { args, expectOutputs: [out], requireFreshOutputs: true });
+    if (!result.ok) {
+        throw new BuildStepError(`divine-create-package failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    const walked = await walk(from, { limit: 200_000 });
+    const staged = new Set(walked.files.map((rel) => rel.split(path.sep).join("/")));
+    const listing = await runTool(location, { args: ["-g", "bg3", "-a", "list-package", "-s", out] });
+    if (!listing.ok) {
+        throw new BuildStepError(`divine-create-package: the pak was written but list-package could not read it back: ` +
+            `${listing.error?.message ?? `exit ${listing.exitCode}`}`, step.id, step.step);
+    }
+    const listed = new Set(listing.stdout
+        .split(/\r?\n/)
+        .map((line) => line.split("\t")[0].trim().replace(/\\/g, "/"))
+        .filter(Boolean));
+    const missing = [...staged].filter((rel) => !listed.has(rel));
+    if (missing.length > 0) {
+        const shown = missing.slice(0, 10).join(", ");
+        throw new BuildStepError(`divine-create-package: ${missing.length} staged file(s) are missing from ${out} (${listed.size} listed): ` +
+            `${shown}${missing.length > 10 ? ", ..." : ""} — a truncated pak`, step.id, step.step);
+    }
+    const outputEntry = await fileEntry(out);
+    return {
+        inputs: [],
+        outputs: [outputEntry],
+        verified: true,
+        tool: "divine",
+        toolVersion: DIVINE_TOOL_VERSION,
+        extras: { pakSha256: outputEntry.sha256, entryCount: listed.size },
+    };
+}
+export async function runVerifyPackageListingStep(step, ctx, of) {
+    const location = await ctx.locateTool("divine");
+    const args = ["-g", "bg3", "-a", "list-package", "-s", of];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `divine ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    assertAbsolute([of]);
+    const result = await runTool(location, { args });
+    if (!result.ok) {
+        throw new BuildStepError(`verify-listing failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    return applyListingRules(step, of, result.stdout, "divine", DIVINE_TOOL_VERSION, { firstTabField: true });
+}

package/dist/core/build/steps/core.js

@@ -0,0 +1,195 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { isDirectory, walk } from "../../fsutil.js";
+import { globToRegExp } from "../../validate/context.js";
+import { runTool } from "../../toolchain/run.js";
+import { TOOL_SPECS } from "../../toolchain/specs.js";
+import { directoryEntry, pathEntries } from "../manifest.js";
+import { resolveOutDirPath, resolveSourceOrStagePath, resolveStageId } from "../paths.js";
+import { writeZipFile } from "../zip.js";
+import { BuildStepError, STEP_FAILURE_OUTPUT_CAP } from "../types.js";
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+async function walkWhole(root, step) {
+    const walked = await walk(root, { limit: 200_000, stat: false });
+    if (walked.truncated) {
+        throw new BuildStepError(`${step.step}: ${root} holds more than 200000 files; the listing was cut short`, step.id, step.step);
+    }
+    return walked;
+}
+export async function runAssertAbsentStep(step, ctx) {
+    const root = resolveStageId(step.in, ctx);
+    if (ctx.mode === "dry-run") {
+        return {
+            inputs: [],
+            outputs: [],
+            verified: true,
+            plan: `check ${root} for forbidden patterns [${step.patterns.join(", ")}]`,
+        };
+    }
+    if (!(await isDirectory(root))) {
+        throw new BuildStepError(`assert-absent: stage subtree not found: ${root}`, step.id, step.step);
+    }
+    const walked = await walkWhole(root, step);
+    const patterns = step.patterns.map(globToRegExp);
+    const matched = walked.files.filter((f) => patterns.some((re) => re.test(toPosix(f))));
+    if (matched.length > 0) {
+        throw new BuildStepError(`assert-absent found forbidden file(s): ${matched.join(", ")}`, step.id, step.step);
+    }
+    return {
+        inputs: [await directoryEntry(root)],
+        outputs: [],
+        verified: true,
+        extras: { checked: walked.files.length, matched: [] },
+    };
+}
+export async function runAssertPresentStep(step, ctx) {
+    const root = resolveStageId(step.in, ctx);
+    if (ctx.mode === "dry-run") {
+        return {
+            inputs: [],
+            outputs: [],
+            verified: true,
+            plan: `check ${root} contains [${step.paths.join(", ")}]`,
+        };
+    }
+    if (!(await isDirectory(root))) {
+        throw new BuildStepError(`assert-present: stage subtree not found: ${root}`, step.id, step.step);
+    }
+    const walked = await walkWhole(root, step);
+    const rels = walked.files.map(toPosix);
+    const patterns = step.paths.map(globToRegExp);
+    const missing = step.paths.filter((_, i) => !rels.some((f) => patterns[i].test(f)));
+    if (missing.length > 0) {
+        throw new BuildStepError(`assert-present: missing required path(s): ${missing.join(", ")}`, step.id, step.step);
+    }
+    return {
+        inputs: [await directoryEntry(root)],
+        outputs: [],
+        verified: true,
+        extras: { checked: walked.files.length, missing: [] },
+    };
+}
+export async function runZipStep(step, ctx) {
+    const from = resolveSourceOrStagePath(step.from, ctx);
+    const out = resolveOutDirPath(step.name, ctx);
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `zip ${from} -> ${out}` };
+    }
+    if (!(await isDirectory(from))) {
+        throw new BuildStepError(`zip: source tree not found: ${from}`, step.id, step.step);
+    }
+    const walked = await walkWhole(from, step);
+    const entries = walked.files
+        .map((rel) => ({ name: toPosix(rel), abs: path.join(from, rel) }))
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    await fs.mkdir(path.dirname(out), { recursive: true });
+    await writeZipFile(out, entries.map((entry) => ({ name: entry.name, read: () => fs.readFile(entry.abs) })));
+    const stat = await fs.stat(out);
+    if (stat.size === 0)
+        throw new BuildStepError(`zip: wrote an empty archive: ${out}`, step.id, step.step);
+    const outputs = await pathEntries([out]);
+    return {
+        inputs: [await directoryEntry(from)],
+        outputs,
+        verified: true,
+        extras: { entryCount: entries.length, sha256: outputs[0]?.sha256 },
+        ...(walked.links && walked.links.length > 0
+            ? { warnings: [`zip: ${walked.links.length} symbolic link(s)/junction(s) under ${from} were not followed and are not in the archive: ${walked.links.slice(0, 10).join(", ")}`] }
+            : {}),
+    };
+}
+export function looksLikePath(raw) {
+    return raw.includes("${stage}") || raw.includes("/") || raw.includes("\\") || path.isAbsolute(raw);
+}
+function resolveArg(raw, ctx) {
+    return looksLikePath(raw) ? resolveSourceOrStagePath(raw, ctx) : raw;
+}
+async function resolveCommandLocation(step, ctx) {
+    const label = `exec:${step.id ?? step.command}`;
+    if (!looksLikePath(step.command)) {
+        try {
+            const located = await ctx.locateTool(step.command);
+            if (located.found && located.path)
+                return { ...located, id: "exec", label };
+            const spec = TOOL_SPECS.find((s) => s.id === step.command);
+            if (spec && ctx.mode !== "dry-run") {
+                throw new BuildStepError(`${label}: "${step.command}" is a toolchain tool the locator could not find${located.hint ? ` (${located.hint})` : ""}. ` +
+                    `Point at it with "toolchain": { "${step.command}": "<path to the executable>" } in modwright.json (a project can carry one), ` +
+                    `or the ${spec.envVar} environment variable, or give the step a path-shaped command.`, step.id, step.step);
+            }
+        }
+        catch (err) {
+            if (err instanceof BuildStepError)
+                throw err;
+        }
+        return { id: "exec", label, found: true, path: step.command, usedBy: [] };
+    }
+    return { id: "exec", label, found: true, path: resolveSourceOrStagePath(step.command, ctx), usedBy: [] };
+}
+export const EXEC_DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+export async function runExecStep(step, ctx) {
+    const location = await resolveCommandLocation(step, ctx);
+    const command = location.path;
+    const cwd = step.cwd ? resolveSourceOrStagePath(step.cwd, ctx) : ctx.projectRoot;
+    const args = step.args.map((a) => resolveArg(a, ctx));
+    const expectOutputs = step.expectOutputs.map((p) => resolveSourceOrStagePath(p, ctx));
+    if (ctx.mode === "dry-run") {
+        return {
+            inputs: [],
+            outputs: [],
+            verified: false,
+            plan: `run ${[...(location.interpreter ?? []), command, ...args].join(" ")} (cwd ${cwd})`,
+            extras: { command, args, cwd, interpreter: location.interpreter },
+        };
+    }
+    for (const out of expectOutputs)
+        await fs.mkdir(path.dirname(out), { recursive: true });
+    const result = await runTool(location, { args, cwd, expectOutputs, timeoutMs: step.timeoutMs ?? EXEC_DEFAULT_TIMEOUT_MS });
+    if (!result.ok) {
+        const output = failureOutput(result, cwd);
+        const said = lastLine(output.stderr) ?? lastLine(output.stdout);
+        throw new BuildStepError(`exec step failed: ${result.error?.message ?? `exit ${result.exitCode}`}${said ? ` Last output: ${said}` : ""}`, step.id, step.step, output);
+    }
+    const warnings = (result.staleOutputs ?? []).map((p) => `${p} was not rewritten by this run (same size and mtime as before it); if the command should always produce it, it is stale from an earlier build.`);
+    return {
+        inputs: [],
+        outputs: await pathEntries(expectOutputs),
+        verified: false,
+        extras: { command, args, cwd, exitCode: result.exitCode, ...(result.envFilled ? { envFilled: result.envFilled } : {}) },
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+}
+function tail(text, cap) {
+    if (text.length <= cap)
+        return { text, truncated: false };
+    return { text: `[...earlier output truncated]\n${text.slice(text.length - cap)}`, truncated: true };
+}
+function lastLine(text) {
+    const line = text
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0)
+        .pop();
+    if (!line)
+        return undefined;
+    return line.length > 300 ? `${line.slice(0, 300)}...` : line;
+}
+function failureOutput(result, cwd) {
+    const stdout = tail(result.stdout, STEP_FAILURE_OUTPUT_CAP);
+    const stderr = tail(result.stderr, STEP_FAILURE_OUTPUT_CAP);
+    return {
+        exitCode: result.exitCode,
+        errorCode: result.error?.code,
+        command: result.command,
+        args: result.args,
+        cwd,
+        stdout: stdout.text,
+        stderr: stderr.text,
+        stdoutTruncated: stdout.truncated || result.stdoutTruncated,
+        stderrTruncated: stderr.truncated || result.stderrTruncated,
+        missingOutputs: result.missingOutputs,
+        ...(result.envFilled ? { envFilled: result.envFilled } : {}),
+    };
+}

package/dist/core/build/steps/cyberpunk.js

@@ -0,0 +1,95 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { pathExists, walk } from "../../fsutil.js";
+import { runTool } from "../../toolchain/run.js";
+import { fileEntry, pathEntries } from "../manifest.js";
+import { resolvedToolNote, resolveOutDirPath, resolveSourceOrStagePath } from "../paths.js";
+import { applyListingRules } from "./listing.js";
+import { BuildStepError } from "../types.js";
+export async function runBlenderExportStep(step, ctx) {
+    const blend = resolveSourceOrStagePath(step.blend, ctx);
+    const script = resolveSourceOrStagePath(step.script, ctx);
+    const out = resolveSourceOrStagePath(step.out, ctx);
+    const location = await ctx.locateTool("blender");
+    const args = [blend, "--background", "--python", script, "--", out];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `blender ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    await fs.mkdir(path.dirname(out), { recursive: true });
+    const result = await runTool(location, { args, expectOutputs: [out], requireFreshOutputs: true });
+    if (!result.ok) {
+        throw new BuildStepError(`blender-export failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    return {
+        inputs: [await fileEntry(blend), await fileEntry(script)],
+        outputs: await pathEntries([out]),
+        verified: true,
+        tool: "blender",
+        toolVersion: location.version,
+    };
+}
+export async function runWolvenkitImportStep(step, ctx) {
+    const glb = resolveSourceOrStagePath(step.glb, ctx);
+    const base = resolveSourceOrStagePath(step.base, ctx);
+    const outDir = resolveSourceOrStagePath(step.outDir, ctx);
+    const outputMesh = path.join(outDir, path.basename(base));
+    const location = await ctx.locateTool("wolvenkit-cli");
+    const args = ["import", glb, "-o", outDir, "-k"];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `wolvenkit-cli ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    const preMtimeMs = (await pathExists(outputMesh)) ? (await fs.stat(outputMesh)).mtimeMs : undefined;
+    await fs.mkdir(outDir, { recursive: true });
+    const result = await runTool(location, { args, expectOutputs: [outputMesh] });
+    if (!result.ok) {
+        throw new BuildStepError(`wolvenkit-import failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    const postMtimeMs = (await fs.stat(outputMesh)).mtimeMs;
+    if (preMtimeMs !== undefined && postMtimeMs === preMtimeMs) {
+        throw new BuildStepError(`wolvenkit-import: ${outputMesh} mtime unchanged after import — it likely wrote nothing despite exiting 0`, step.id, step.step);
+    }
+    return {
+        inputs: [await fileEntry(glb)],
+        outputs: await pathEntries([outputMesh]),
+        verified: true,
+        tool: "wolvenkit-cli",
+        toolVersion: location.version,
+        extras: { keepBase: true, baseMeshSha256: (await fileEntry(outputMesh)).sha256 },
+    };
+}
+export async function runWolvenkitPackStep(step, ctx) {
+    const from = resolveSourceOrStagePath(step.from, ctx);
+    const out = resolveOutDirPath(step.out, ctx);
+    const location = await ctx.locateTool("wolvenkit-cli");
+    const args = ["pack", from, "-o", path.dirname(out), "-v", step.verbosity];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `wolvenkit-cli ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    await fs.mkdir(path.dirname(out), { recursive: true });
+    const result = await runTool(location, { args, expectOutputs: [out], requireFreshOutputs: true });
+    if (!result.ok) {
+        throw new BuildStepError(`wolvenkit-pack failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    const walked = await walk(from, { limit: 200_000 });
+    const outputEntry = await fileEntry(out);
+    return {
+        inputs: [],
+        outputs: [outputEntry],
+        verified: true,
+        tool: "wolvenkit-cli",
+        toolVersion: location.version,
+        extras: { archiveSha256: outputEntry.sha256, entryCount: walked.files.length },
+    };
+}
+export async function runVerifyArchiveListingStep(step, ctx, of) {
+    const location = await ctx.locateTool("wolvenkit-cli");
+    const args = ["archive", of, "-l"];
+    if (ctx.mode === "dry-run") {
+        return { inputs: [], outputs: [], verified: true, plan: `wolvenkit-cli ${args.join(" ")}${resolvedToolNote(location)}` };
+    }
+    const result = await runTool(location, { args });
+    if (!result.ok) {
+        throw new BuildStepError(`verify-listing failed: ${result.error?.message ?? `exit ${result.exitCode}`}`, step.id, step.step);
+    }
+    return applyListingRules(step, of, result.stdout, "wolvenkit-cli", location.version);
+}

package/dist/core/build/steps/listing.js

@@ -0,0 +1,35 @@
+import { globToRegExp } from "../../validate/context.js";
+import { pathEntries } from "../manifest.js";
+import { BuildStepError } from "../types.js";
+export async function applyListingRules(step, of, stdout, tool, toolVersion, options = {}) {
+    const listing = stdout
+        .split(/\r?\n/)
+        .map((line) => (options.firstTabField ? (line.split("\t")[0] ?? line) : line))
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const deny = [];
+    const exceptions = [];
+    for (const raw of step.forbid ?? []) {
+        if (raw.startsWith("!"))
+            exceptions.push(globToRegExp(raw.slice(1)));
+        else
+            deny.push(globToRegExp(raw));
+    }
+    const matched = listing.filter((entry) => deny.some((re) => re.test(entry)) && !exceptions.some((re) => re.test(entry)));
+    const requirePatterns = (step.require ?? []).map(globToRegExp);
+    const unmetRequire = (step.require ?? []).filter((_, i) => !listing.some((entry) => requirePatterns[i].test(entry)));
+    if (matched.length > 0) {
+        throw new BuildStepError(`verify-listing: forbidden ${matched.length === 1 ? "entry" : "entries"} in ${of}: ${matched.join(", ")}`, step.id, step.step);
+    }
+    if (unmetRequire.length > 0) {
+        throw new BuildStepError(`verify-listing: required pattern(s) missing from ${of}: ${unmetRequire.join(", ")}`, step.id, step.step);
+    }
+    return {
+        inputs: await pathEntries([of]),
+        outputs: [],
+        verified: true,
+        tool,
+        toolVersion,
+        extras: { entryCount: listing.length, matched: [] },
+    };
+}

package/dist/core/build/types.js

@@ -0,0 +1,13 @@
+export const STEP_FAILURE_OUTPUT_CAP = 8_000;
+export class BuildStepError extends Error {
+    stepId;
+    stepKind;
+    output;
+    constructor(message, stepId, stepKind, output) {
+        super(message);
+        this.stepId = stepId;
+        this.stepKind = stepKind;
+        this.output = output;
+        this.name = "BuildStepError";
+    }
+}

package/dist/core/build/zip.js

@@ -0,0 +1,148 @@
+import { promises as fs } from "node:fs";
+import { promisify } from "node:util";
+import { deflateRaw, deflateRawSync } from "node:zlib";
+const deflateRawAsync = promisify(deflateRaw);
+const CRC_TABLE = buildCrcTable();
+function buildCrcTable() {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+}
+export function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export const FIXED_DOS_TIME = 0;
+export const FIXED_DOS_DATE = 0x21;
+const VERSION_NEEDED = 20;
+const VERSION_MADE_BY = 0x0314;
+const FLAG_UTF8 = 0x0800;
+const METHOD_DEFLATE = 8;
+const METHOD_STORE = 0;
+function u16(n) {
+    const b = Buffer.alloc(2);
+    b.writeUInt16LE(n & 0xffff, 0);
+    return b;
+}
+function u32(n) {
+    const b = Buffer.alloc(4);
+    b.writeUInt32LE(n >>> 0, 0);
+    return b;
+}
+const MAX_ZIP32 = 0xffffffff;
+const MAX_ZIP_ENTRIES = 0xffff;
+export function createZip(entries) {
+    assertEntryCount(entries.length);
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const records = entryRecords(entry.name, entry.data, deflateRawSync(entry.data), offset);
+        localParts.push(records.local);
+        centralParts.push(records.central);
+        offset += records.local.length;
+    }
+    const centralDir = Buffer.concat(centralParts);
+    return Buffer.concat([...localParts, centralDir, endOfCentralDirectory(entries.length, centralDir.length, offset)]);
+}
+export async function writeZipFile(outPath, entries) {
+    assertEntryCount(entries.length);
+    const tmp = `${outPath}.${process.pid}.${Date.now()}.tmp`;
+    const handle = await fs.open(tmp, "w");
+    try {
+        const centralParts = [];
+        let offset = 0;
+        for (const entry of entries) {
+            const data = await entry.read();
+            const records = entryRecords(entry.name, data, await deflateRawAsync(data), offset);
+            await handle.write(records.local);
+            centralParts.push(records.central);
+            offset += records.local.length;
+        }
+        const centralDir = Buffer.concat(centralParts);
+        await handle.write(centralDir);
+        await handle.write(endOfCentralDirectory(entries.length, centralDir.length, offset));
+        await handle.close();
+        await fs.rename(tmp, outPath);
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        await fs.rm(tmp, { force: true }).catch(() => { });
+        throw err;
+    }
+}
+function assertEntryCount(count) {
+    if (count > MAX_ZIP_ENTRIES) {
+        throw new Error(`zip: ${count} entries exceed the ${MAX_ZIP_ENTRIES} a non-ZIP64 archive can hold`);
+    }
+}
+function entryRecords(name, data, deflated, offset) {
+    const nameBuf = Buffer.from(name.replace(/\\/g, "/"), "utf8");
+    if (data.length > MAX_ZIP32 || nameBuf.length > 0xffff) {
+        throw new Error(`zip: ${name} is ${data.length} bytes, past the 4 GiB a non-ZIP64 entry can hold`);
+    }
+    if (offset > MAX_ZIP32) {
+        throw new Error(`zip: the archive would pass 4 GiB, which needs ZIP64 records this writer does not emit`);
+    }
+    const crc = crc32(data);
+    const useStore = deflated.length >= data.length;
+    const method = useStore ? METHOD_STORE : METHOD_DEFLATE;
+    const payload = useStore ? data : deflated;
+    const localHeader = Buffer.concat([
+        u32(0x04034b50),
+        u16(VERSION_NEEDED),
+        u16(FLAG_UTF8),
+        u16(method),
+        u16(FIXED_DOS_TIME),
+        u16(FIXED_DOS_DATE),
+        u32(crc),
+        u32(payload.length),
+        u32(data.length),
+        u16(nameBuf.length),
+        u16(0),
+    ]);
+    const centralHeader = Buffer.concat([
+        u32(0x02014b50),
+        u16(VERSION_MADE_BY),
+        u16(VERSION_NEEDED),
+        u16(FLAG_UTF8),
+        u16(method),
+        u16(FIXED_DOS_TIME),
+        u16(FIXED_DOS_DATE),
+        u32(crc),
+        u32(payload.length),
+        u32(data.length),
+        u16(nameBuf.length),
+        u16(0),
+        u16(0),
+        u16(0),
+        u16(0),
+        u32(0),
+        u32(offset),
+    ]);
+    return { local: Buffer.concat([localHeader, nameBuf, payload]), central: Buffer.concat([centralHeader, nameBuf]) };
+}
+function endOfCentralDirectory(count, centralSize, centralOffset) {
+    if (centralOffset > MAX_ZIP32 || centralSize > MAX_ZIP32) {
+        throw new Error(`zip: the archive would pass 4 GiB, which needs ZIP64 records this writer does not emit`);
+    }
+    return Buffer.concat([
+        u32(0x06054b50),
+        u16(0),
+        u16(0),
+        u16(count),
+        u16(count),
+        u32(centralSize),
+        u32(centralOffset),
+        u16(0),
+    ]);
+}