@openclaw/fs-safe 0.8.6 → 0.10.0

package/dist/archive-merge.js

@@ -1,3 +1,4 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ownExtractionDestinationMutation } from "./archive-deadline.js";
@@ -10,13 +11,18 @@ import { formatErrorDetail } from "./error-detail.js";
 import { isPathInside } from "./path.js";
 import { root } from "./root.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
+import { onCopyPublication } from "./copy-publication.js";
+import { syncFileBestEffortSync } from "./file-sync.js";
+import { finalizeArchivePublication } from "./archive-durability.js";
 export async function mergePlannedArchiveIntoDestination(params) {
-    await mergeTree(params, params.entries);
+    await mergeTree(params, params.entries, params.durable === true);
 }
 export async function mergeExtractedTreeIntoDestination(params) {
     await mergeTree(params);
 }
-async function mergeTree(params, publication) {
+async function mergeTree(params, publication, durable = true) {
+    const publishedFiles = [];
+    const publishedDirectories = [];
     const check = () => params.deadline?.check();
     check();
     const destinationGuard = await createDirectoryIdentityGuard(params.destinationRealDir);
@@ -29,7 +35,7 @@ async function mergeTree(params, publication) {
     for (const entry of publication ?? []) {
         // Resolve admitted spelling in private staging, preserving the volume's case
         // and Unicode behavior without assigning explicit modes to distinct parents.
-        const stagedPath = await fs.realpath(path.join(params.sourceDir, entry.path));
+        const stagedPath = fsSync.realpathSync.native(path.join(params.sourceDir, entry.path));
         check();
         if (!isPathInside(sourceGuard.realPath, stagedPath) || plan.has(stagedPath)) {
             throw new FsSafeError("path-mismatch", "archive publication paths changed in staging");
@@ -59,11 +65,11 @@ async function mergeTree(params, publication) {
             const relPath = path.relative(params.sourceDir, sourcePath);
             const originalPath = relPath.split(path.sep).join("/");
             const destinationPath = path.join(params.destinationDir, relPath);
-            const sourceStat = await fs.lstat(sourcePath);
+            const sourceStat = fsSync.lstatSync(sourcePath);
             check();
             if (sourceStat.isSymbolicLink())
                 throw createArchiveSymlinkTraversalError(originalPath);
-            const sourceReal = await fs.realpath(sourcePath);
+            const sourceReal = fsSync.realpathSync.native(sourcePath);
             check();
             if (!isPathInside(sourceGuard.realPath, sourceReal))
                 throw createArchiveSymlinkTraversalError(originalPath);
@@ -78,7 +84,7 @@ async function mergeTree(params, publication) {
             const mode = plan ? planned?.mode ?? 0o755 : sourceStat.mode & 0o777;
             await preparePrivateArchiveOutputPath({
                 ...params, relPath, outPath: destinationPath, originalPath, isDirectory: kind === "directory",
-            }, assertGuards);
+            }, assertGuards, destinationGuard);
             check();
             if (kind === "directory") {
                 // Ownership spans open, descendants, finalization and close, including timeout.
@@ -98,6 +104,11 @@ async function mergeTree(params, publication) {
                         ancestors.push({ guard, owner });
                         try {
                             await walk(sourcePath);
+                            if (publication) {
+                                await assertGuards();
+                                publishedDirectories.push({ guard, mode, parents: ancestors.slice(0, -1).map((ancestor) => ancestor.guard) });
+                                return;
+                            }
                             await getFsSafeTestHooks()?.beforeArchiveOutputMutation?.("chmod", destinationPath);
                             check();
                             await assertGuards();
@@ -129,21 +140,39 @@ async function mergeTree(params, publication) {
                 await ownExtractionDestinationMutation(params.deadline, async () => {
                     await assertGuards();
                     try {
-                        await targetRoot.copyIn(relPath, sourcePath, { mkdir: true, mode });
+                        const options = {
+                            mkdir: true, mode, durable: publication ? false : true,
+                        };
+                        if (publication && durable) {
+                            options[onCopyPublication] = async (fd, identity) => {
+                                check();
+                                if ((mode & 0o400) === 0) {
+                                    // Final mode may prohibit reopening. Sync the writer's still-owned
+                                    // descriptor without widening permissions or syncing its parent.
+                                    syncFileBestEffortSync(fd);
+                                    check();
+                                }
+                                else {
+                                    publishedFiles.push({ relativePath: relPath, identity,
+                                        guards: ancestors.map((ancestor) => ancestor.guard) });
+                                }
+                            };
+                        }
+                        await targetRoot.copyIn(relPath, sourcePath, options);
                         check();
                         await assertGuards();
                         await assertResolvedInsideDestination({
                             destinationRealDir: params.destinationRealDir, targetPath: destinationPath, originalPath,
                         });
                         check();
-                        const stat = await fs.lstat(destinationPath);
+                        const stat = fsSync.lstatSync(destinationPath);
                         check();
                         if (stat.isSymbolicLink() || (stat.isFile() && stat.nlink > 1)) {
                             throw createArchiveSymlinkTraversalError(originalPath);
                         }
                     }
                     catch (error) {
-                        // copyIn alone owns cleanup; no receipt permits archive-layer unlink.
+                        // copyIn cleans unpublished stages; merge never gains rollback authority.
                         if (error instanceof FsSafeError && (error.code === "hardlink" || error.code === "path-alias")) {
                             throw createArchiveSymlinkTraversalError(originalPath);
                         }
@@ -154,4 +183,8 @@ async function mergeTree(params, publication) {
         }
     };
     await walk(params.sourceDir);
+    if (publication) {
+        await finalizeArchivePublication({ targetRoot, destinationGuard, sourceGuard,
+            files: publishedFiles, directories: publishedDirectories, durable, deadline: params.deadline });
+    }
 }

package/dist/archive-native.d.ts

@@ -5,6 +5,7 @@ import type { ExtractArchiveOptions } from "./archive-options.js";
 import type { NativeBinding } from "./native.js";
 export declare function throwMappedNativeArchiveError(error: unknown): never;
 export declare function extractNativeArchive(params: {
+    durable?: boolean;
     binding: NativeBinding;
     archivePath: string;
     destDir: string;

package/dist/archive-native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-native.d.ts","sourceRoot":"","sources":["../src/archive-native.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAOlE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAYnE;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,4BAA4B,CAAC;IACrC,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;CAClD,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FhB"}
+{"version":3,"file":"archive-native.d.ts","sourceRoot":"","sources":["../src/archive-native.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAOlE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAYnE;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,4BAA4B,CAAC;IACrC,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;CAClD,GAAG,OAAO,CAAC,IAAI,CAAC,CA+FhB"}

package/dist/archive-native.js

@@ -40,8 +40,9 @@ export async function extractNativeArchive(params) {
             destinationRealDir,
             run: async (stagingDir) => {
                 params.deadline.check();
+                // N-API retains completed task state on its signal; each pass needs its own.
                 const manifest = await params.binding
-                    .inspectArchiveNative(stagedArchive.path, params.kind, tarLimits, params.deadline.signal)
+                    .inspectArchiveNative(stagedArchive.path, params.kind, tarLimits, AbortSignal.any([params.deadline.signal]))
                     .catch(throwMappedNativeArchiveError);
                 params.deadline.check();
                 assertArchiveEntryCountWithinLimit(manifest.length, limits);
@@ -84,7 +85,7 @@ export async function extractNativeArchive(params) {
                     (typeof fsConstants.O_DIRECTORY === "number" ? fsConstants.O_DIRECTORY : 0));
                 try {
                     params.deadline.check();
-                    await params.binding.extractArchiveNative(stagedArchive.path, params.kind, directory.fd, plan.map((entry) => ({ ...entry, mode: entry.kind === "directory" ? 0o700 : 0o600 })), tarLimits, params.deadline.signal).catch(throwMappedNativeArchiveError);
+                    await params.binding.extractArchiveNative(stagedArchive.path, params.kind, directory.fd, plan.map((entry) => ({ ...entry, mode: entry.kind === "directory" ? 0o700 : 0o600 })), tarLimits, AbortSignal.any([params.deadline.signal])).catch(throwMappedNativeArchiveError);
                 }
                 finally {
                     await directory.close().catch(() => undefined);
@@ -92,6 +93,7 @@ export async function extractNativeArchive(params) {
                 params.deadline.check();
                 await mergePlannedArchiveIntoDestination({
                     entries: plan,
+                    durable: params.durable,
                     sourceDir: stagingDir,
                     destinationDir: params.destDir,
                     destinationRealDir,

package/dist/archive-options.d.ts

@@ -9,6 +9,8 @@ export type ExtractArchiveOptions = {
     archivePath: string;
     destDir: string;
     timeoutMs: number;
+    /** Sync published files and directories before returning. Defaults to false. */
+    durable?: boolean;
     kind?: ArchiveKind;
     stripComponents?: number;
     tarGzip?: boolean;

package/dist/archive-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-options.d.ts","sourceRoot":"","sources":["../src/archive-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,CAAC"}
+{"version":3,"file":"archive-options.d.ts","sourceRoot":"","sources":["../src/archive-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,CAAC"}

package/dist/archive-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAcA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAkLpG,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,GAChD,OAAO,CAAC,MAAM,CAAC,CA6EjB"}
+{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAeA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAiOpG,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,GAChD,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

package/dist/archive-read.js

@@ -1,7 +1,8 @@
 import { classifyArchiveParserError } from "./archive-parser-errors.js";
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import { Readable } from "node:stream";
-import { readFileHandleBounded } from "./bounded-read.js";
+import { readBoundedAsync } from "./bounded-read.js";
 import { ArchiveFormatError, ArchiveSecurityError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
 import { formatErrorDetail } from "./error-detail.js";
 import { stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
@@ -16,7 +17,6 @@ import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { getNativeBinding } from "./native.js";
 import { admitZipBuffer } from "./archive-zip-admission.js";
 import { resolveExtractLimits, resolveTarMeterLimits } from "./archive-limits.js";
-import { tempFile } from "./temp-target.js";
 const ZIP_UNIX_FILE_TYPE_MASK = 0o170000;
 const ZIP_UNIX_SYMLINK_TYPE = 0o120000;
 function canonicalEntryPath(entryPath) {
@@ -62,37 +62,37 @@ async function readStreamBounded(stream, maxBytes) {
     }
     return Buffer.concat(chunks, total);
 }
-async function stageArchiveInput(archivePath) {
-    const resolved = await fs.realpath(archivePath);
+async function readArchiveInput(archivePath) {
+    const resolved = fsSync.realpathSync.native(archivePath);
     const before = await inspectFileIdentity(async () => {
-        const stat = await fs.lstat(archivePath, { bigint: true });
+        const stat = fsSync.lstatSync(archivePath, { bigint: true });
         if (stat.isSymbolicLink() || !stat.isFile()) {
             throw new Error(`archive is not a regular file: ${archivePath}`);
         }
         return stat;
     });
     const handle = await fs.open(resolved, resolveReadOpenFlags());
-    let staged;
     try {
-        staged = await tempFile({ prefix: "fs-safe-archive-read", fileName: "archive.bin" });
         const opened = await inspectFileIdentity(async () => {
-            const stat = await handle.stat({ bigint: true });
+            const stat = fsSync.fstatSync(handle.fd, { bigint: true });
             if (!stat.isFile())
                 throw new Error("archive changed during validation");
             return stat;
         }, before);
         await inspectFileIdentity(async () => {
-            const stat = await fs.lstat(resolved, { bigint: true });
+            const stat = fsSync.lstatSync(resolved, { bigint: true });
             if (stat.isSymbolicLink() || !stat.isFile())
                 throw new Error("archive changed during validation");
             return stat;
         }, opened);
-        const buffer = await readFileHandleBounded(handle, DEFAULT_MAX_ARCHIVE_BYTES_ZIP);
-        await fs.writeFile(staged.path, buffer, { flag: "wx", mode: 0o600 });
-        return { path: staged.path, buffer, cleanup: staged.cleanup };
+        // Native archive workers borrow this private buffer. A pooled allocation could
+        // share its ArrayBuffer with unrelated JS buffers while the worker runs.
+        return await readBoundedAsync(DEFAULT_MAX_ARCHIVE_BYTES_ZIP, async (buffer, length) => (await handle.read(buffer, 0, length, null)).bytesRead, { unpooled: true, observeRegularFileSize: () => {
+                const size = fsSync.fstatSync(handle.fd).size;
+                return Number.isSafeInteger(size) && size >= 0 ? size : undefined;
+            } });
     }
     catch (error) {
-        await staged?.cleanup().catch(() => undefined);
         if (error instanceof FsSafeError && error.code === "path-mismatch") {
             throw new FsSafeError("path-mismatch", "archive changed during validation", { cause: error });
         }
@@ -133,11 +133,11 @@ async function readZipEntry(buffer, entryPath, maxBytes) {
     stream.once("error", (error) => integrity.destroy(normalizeZipIntegrityError(error)));
     return await readStreamBounded(stream.pipe(integrity), maxBytes);
 }
-async function readTarEntry(archivePath, entryPath, maxBytes) {
+async function readTarEntry(archiveBuffer, entryPath, maxBytes) {
     const seenPaths = new Set();
     let selected;
     const limits = resolveTarMeterLimits();
-    await inspectTar({ archivePath, limits, onMember(info) {
+    await inspectTar({ archiveBuffer, limits, onMember(info) {
             const normalized = canonicalEntryPath(info.path);
             if (seenPaths.has(normalized)) {
                 throw new ArchiveSecurityError("entry-path", `archive contains duplicate entry path: ${formatErrorDetail(normalized)}`);
@@ -154,11 +154,57 @@ async function readTarEntry(archivePath, entryPath, maxBytes) {
     if (selected.size > maxBytes)
         throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT);
     let result;
-    await replayTar({ archivePath, limits, members: [selected], async consume(_member, payload) {
+    await replayTar({ archiveBuffer, limits, members: [selected], async consume(_member, payload) {
             result = await readStreamBounded(payload, maxBytes);
         } });
     return result;
 }
+function selectNativeEntry(manifest, requested, displayPath, physicalCount) {
+    if (physicalCount !== undefined && manifest.length !== physicalCount) {
+        throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
+    }
+    const seen = new Set();
+    let selected;
+    for (const entry of manifest) {
+        const normalized = canonicalEntryPath(entry.path);
+        if (seen.has(normalized)) {
+            throw new ArchiveSecurityError("entry-path", `archive contains duplicate entry path: ${formatErrorDetail(normalized)}`);
+        }
+        seen.add(normalized);
+        if (normalized === requested) {
+            if (entry.kind !== "file")
+                throw new Error(`archive entry is not a file: ${formatErrorDetail(displayPath)}`);
+            selected = entry;
+        }
+    }
+    if (!selected)
+        throw new Error(`archive entry not found: ${formatErrorDetail(displayPath)}`);
+    return selected;
+}
+function throwNativeReadError(error) {
+    if (error instanceof Error) {
+        const mapped = classifyArchiveParserError(error.message, { cause: error });
+        if (mapped)
+            throw mapped;
+        if (isArchiveFormatErrorMessage(error.message))
+            throw new ArchiveFormatError(error.message, { cause: error });
+    }
+    throw error;
+}
+async function readNativeBufferEntry(native, buffer, kind, requested, displayPath, maxBytes, physicalCount) {
+    try {
+        const signal = new AbortController().signal;
+        const limits = resolveTarMeterLimits();
+        const reader = kind === "zip"
+            ? await native.openZipBufferNative(buffer, limits, AbortSignal.any([signal]))
+            : await native.openTarBufferNative(buffer, kind, limits, AbortSignal.any([signal]));
+        const selected = selectNativeEntry(reader.entries, requested, displayPath, physicalCount);
+        return await reader.readEntry(selected.index, maxBytes, AbortSignal.any([signal]));
+    }
+    catch (error) {
+        throwNativeReadError(error);
+    }
+}
 export async function readArchiveEntry(archivePath, entryPath, options) {
     if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
         throw new RangeError("maxBytes must be a non-negative safe integer");
@@ -168,58 +214,14 @@ export async function readArchiveEntry(archivePath, entryPath, options) {
         throw new Error(`unsupported archive: ${archivePath}`);
     }
     const requestedEntry = normalizedRequestedEntry(entryPath);
-    const staged = await stageArchiveInput(archivePath);
-    try {
-        const physicalCount = kind === "zip"
-            ? admitZipBuffer(staged.buffer, resolveExtractLimits())
-            : undefined;
-        const native = getNativeBinding();
-        if (native) {
-            try {
-                const signal = new AbortController().signal;
-                const limits = resolveTarMeterLimits();
-                const manifest = await native.inspectArchiveNative(staged.path, kind, limits, signal);
-                let rawEntryPath;
-                if (physicalCount !== undefined && manifest.length !== physicalCount) {
-                    throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
-                }
-                const seenPaths = new Set();
-                for (const entry of manifest) {
-                    const normalized = canonicalEntryPath(entry.path);
-                    if (seenPaths.has(normalized)) {
-                        throw new ArchiveSecurityError("entry-path", `archive contains duplicate entry path: ${formatErrorDetail(normalized)}`);
-                    }
-                    seenPaths.add(normalized);
-                    if (normalized === requestedEntry) {
-                        if (entry.kind !== "file") {
-                            throw new Error(`archive entry is not a file: ${formatErrorDetail(entryPath)}`);
-                        }
-                        rawEntryPath = entry.path;
-                    }
-                }
-                if (!rawEntryPath) {
-                    throw new Error(`archive entry not found: ${formatErrorDetail(entryPath)}`);
-                }
-                return await native.readArchiveEntryNative(staged.path, kind, rawEntryPath, options.maxBytes, limits, signal);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    const mapped = classifyArchiveParserError(error.message, { cause: error });
-                    if (mapped)
-                        throw mapped;
-                }
-                if (error instanceof Error && isArchiveFormatErrorMessage(error.message)) {
-                    throw new ArchiveFormatError(error.message, { cause: error });
-                }
-                throw error;
-            }
-        }
-        assertPortableArchiveKind(kind);
-        return kind === "zip"
-            ? await readZipEntry(staged.buffer, requestedEntry, options.maxBytes)
-            : await readTarEntry(staged.path, requestedEntry, options.maxBytes);
-    }
-    finally {
-        await staged.cleanup();
-    }
+    const buffer = await readArchiveInput(archivePath);
+    const physicalCount = kind === "zip"
+        ? admitZipBuffer(buffer, resolveExtractLimits())
+        : undefined;
+    const native = getNativeBinding();
+    if (native)
+        return await readNativeBufferEntry(native, buffer, kind, requestedEntry, entryPath, options.maxBytes, physicalCount);
+    assertPortableArchiveKind(kind);
+    return kind === "zip" ? await readZipEntry(buffer, requestedEntry, options.maxBytes)
+        : await readTarEntry(buffer, requestedEntry, options.maxBytes);
 }

package/dist/archive-staging.d.ts

@@ -20,7 +20,7 @@ type ArchiveOutputPathParams = {
     deadline?: ExtractionDeadline;
 };
 export declare function prepareArchiveOutputPath(params: ArchiveOutputPathParams): Promise<void>;
-export declare function preparePrivateArchiveOutputPath(params: ArchiveOutputPathParams, assertGuards?: () => Promise<void>): Promise<void>;
+export declare function preparePrivateArchiveOutputPath(params: ArchiveOutputPathParams, assertGuards?: () => Promise<void>, destinationGuard?: AsyncDirectoryGuard): Promise<void>;
 export declare function withStagedArchiveDestination<T>(params: {
     destinationRealDir: string;
     stagingDirPrefix?: string;

package/dist/archive-staging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-staging.d.ts","sourceRoot":"","sources":["../src/archive-staging.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,oBAAoB,EAErB,MAAM,qBAAqB,CAAC;AAkB7B,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS1F,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAS5F;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY5F;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BnF;AA0BD,wBAAsB,+BAA+B,CAAC,MAAM,EAAE;IAC5D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB;AAiBD,KAAK,uBAAuB,GAAG;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;AAED,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,uBAAuB,EAAE,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAClE,OAAO,CAAC,IAAI,CAAC,CAEf;AA8GD,wBAAsB,4BAA4B,CAAC,CAAC,EAAE,MAAM,EAAE;IAC5D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACzC,GAAG,OAAO,CAAC,CAAC,CAAC,CA6Bb;AAED,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAEvE,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,MAAM,GAAG,oBAAoB,CAE7F"}
+{"version":3,"file":"archive-staging.d.ts","sourceRoot":"","sources":["../src/archive-staging.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,oBAAoB,EAErB,MAAM,qBAAqB,CAAC;AAkB7B,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS1F,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAS5F;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY5F;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BnF;AA0BD,wBAAsB,+BAA+B,CAAC,MAAM,EAAE;IAC5D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB;AAiBD,KAAK,uBAAuB,GAAG;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;AAED,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,uBAAuB,EAAE,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACnE,gBAAgB,CAAC,EAAE,mBAAmB,GACrC,OAAO,CAAC,IAAI,CAAC,CAEf;AAkHD,wBAAsB,4BAA4B,CAAC,CAAC,EAAE,MAAM,EAAE;IAC5D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACzC,GAAG,OAAO,CAAC,CAAC,CAAC,CA6Bb;AAED,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAEvE,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,MAAM,GAAG,oBAAoB,CAE7F"}

package/dist/archive-staging.js

@@ -1,3 +1,4 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, } from "./directory-guard.js";
@@ -44,16 +45,16 @@ export async function assertDirectoryIdentityGuard(guard) {
     }
 }
 export async function prepareArchiveDestinationDir(destDir) {
-    const stat = await fs.lstat(destDir);
+    const stat = fsSync.lstatSync(destDir);
     if (stat.isSymbolicLink()) {
         throw new ArchiveSecurityError("destination-symlink", "archive destination is a symlink");
     }
     if (!stat.isDirectory()) {
         throw new ArchiveSecurityError("destination-not-directory", "archive destination is not a directory");
     }
-    const realPath = await fs.realpath(destDir);
-    const realStat = await fs.stat(realPath);
-    const postStat = await fs.lstat(destDir);
+    const realPath = fsSync.realpathSync.native(destDir);
+    const realStat = fsSync.statSync(realPath);
+    const postStat = fsSync.lstatSync(destDir);
     if (realStat.dev !== stat.dev ||
         realStat.ino !== stat.ino ||
         postStat.isSymbolicLink() ||
@@ -71,7 +72,7 @@ async function assertNoSymlinkTraversal(params) {
         current = path.join(current, part);
         let stat;
         try {
-            stat = await fs.lstat(current);
+            stat = fsSync.lstatSync(current);
         }
         catch (err) {
             if (isNotFoundPathError(err)) {
@@ -87,7 +88,7 @@ async function assertNoSymlinkTraversal(params) {
 export async function assertResolvedInsideDestination(params) {
     let resolved;
     try {
-        resolved = await fs.realpath(params.targetPath);
+        resolved = fsSync.realpathSync.native(params.targetPath);
     }
     catch (err) {
         if (isNotFoundPathError(err)) {
@@ -113,10 +114,10 @@ async function mkdirArchiveOutput(params) {
 export async function prepareArchiveOutputPath(params) {
     await prepareOutputPath(params);
 }
-export async function preparePrivateArchiveOutputPath(params, assertGuards) {
-    await prepareOutputPath(params, assertGuards, true);
+export async function preparePrivateArchiveOutputPath(params, assertGuards, destinationGuard) {
+    await prepareOutputPath(params, assertGuards, true, destinationGuard);
 }
-async function prepareOutputPath(params, assertGuards, privateWorkingMode = false) {
+async function prepareOutputPath(params, assertGuards, privateWorkingMode = false, existingDestinationGuard) {
     checkExtractionDeadline(params.deadline);
     const targetRoot = privateWorkingMode ? {
         async mkdir(relativePath) {
@@ -136,16 +137,24 @@ async function prepareOutputPath(params, assertGuards, privateWorkingMode = fals
                 mode: 0o700,
                 rejectSymlinks: true,
                 beforeComponent: async () => {
-                    await assertDirectoryIdentityGuard(destinationGuard);
-                    checkExtractionDeadline(params.deadline);
-                    await assertGuards?.();
+                    await assertOutputGuards();
                     checkExtractionDeadline(params.deadline);
                 },
             });
         },
     } : await root(params.destinationRealDir);
     checkExtractionDeadline(params.deadline);
-    const destinationGuard = await createDirectoryIdentityGuard(params.destinationRealDir);
+    const destinationGuard = existingDestinationGuard ?? await createDirectoryIdentityGuard(params.destinationRealDir);
+    const assertOutputGuards = async () => {
+        // The merge's callback verifies this same original destination guard.
+        if (existingDestinationGuard && assertGuards)
+            await assertGuards();
+        else {
+            await assertDirectoryIdentityGuard(destinationGuard);
+            checkExtractionDeadline(params.deadline);
+            await assertGuards?.();
+        }
+    };
     checkExtractionDeadline(params.deadline);
     const relPath = params.relPath.split(path.sep).join(path.posix.sep);
     await assertNoSymlinkTraversal({
@@ -158,9 +167,7 @@ async function prepareOutputPath(params, assertGuards, privateWorkingMode = fals
         await getFsSafeTestHooks()?.beforeArchiveOutputMutation?.("mkdir", params.outPath);
         checkExtractionDeadline(params.deadline);
         await ownExtractionDestinationMutation(params.deadline, async () => {
-            await assertDirectoryIdentityGuard(destinationGuard);
-            checkExtractionDeadline(params.deadline);
-            await assertGuards?.();
+            await assertOutputGuards();
             checkExtractionDeadline(params.deadline);
             await mkdirArchiveOutput({
                 targetRoot,
@@ -184,9 +191,7 @@ async function prepareOutputPath(params, assertGuards, privateWorkingMode = fals
         await getFsSafeTestHooks()?.beforeArchiveOutputMutation?.("mkdir", path.dirname(params.outPath));
         checkExtractionDeadline(params.deadline);
         await ownExtractionDestinationMutation(params.deadline, async () => {
-            await assertDirectoryIdentityGuard(destinationGuard);
-            checkExtractionDeadline(params.deadline);
-            await assertGuards?.();
+            await assertOutputGuards();
             checkExtractionDeadline(params.deadline);
             await mkdirArchiveOutput({
                 targetRoot,

package/dist/archive-tar-stream.d.ts

@@ -1,18 +1,25 @@
 import type { TarMeterLimits } from "./archive-limits.js";
 import { type AdmittedTarMember } from "./archive-tar-wasm.js";
-export declare function inspectTar(params: {
+/** Buffers are private immutable snapshots, just like the staged file route. */
+type TarInput = {
     archivePath: string;
+    archiveBuffer?: never;
+} | {
+    archiveBuffer: Buffer;
+    archivePath?: never;
+};
+export declare function inspectTar(params: TarInput & {
     limits: TarMeterLimits;
     signal?: AbortSignal;
     onMember?: (entry: AdmittedTarMember) => void;
 }): Promise<void>;
 /** Replay in physical order, retaining at most one decoded chunk. Every range
- * comes from complete admission of the immutable staged input. */
-export declare function replayTar<T extends AdmittedTarMember>(params: {
-    archivePath: string;
+ * comes from complete admission of the immutable input. */
+export declare function replayTar<T extends AdmittedTarMember>(params: TarInput & {
     limits: TarMeterLimits;
     signal?: AbortSignal;
     members: readonly T[];
     consume(member: T, payload: AsyncIterable<Buffer>): Promise<void>;
 }): Promise<void>;
+export {};
 //# sourceMappingURL=archive-tar-stream.d.ts.map

package/dist/archive-tar-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-stream.d.ts","sourceRoot":"","sources":["../src/archive-tar-stream.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AA4ChF,wBAAsB,UAAU,CAAC,MAAM,EAAE;IACvC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAClE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC/C,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAED;kEACkE;AAClE,wBAAsB,SAAS,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACnE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAClE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IACtB,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}
+{"version":3,"file":"archive-tar-stream.d.ts","sourceRoot":"","sources":["../src/archive-tar-stream.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAEhF,gFAAgF;AAChF,KAAK,QAAQ,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC;AAuDhH,wBAAsB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG;IAClD,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC7C,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC/C,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAED;2DAC2D;AAC3D,wBAAsB,SAAS,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE,QAAQ,GAAG;IAC9E,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC7C,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IACtB,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}

package/dist/archive-tar-stream.js

@@ -1,10 +1,14 @@
 import fs from "node:fs";
-import { Writable } from "node:stream";
+import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
-import { GzipInput, validateGzipContainerTail } from "./archive-gzip-tail.js";
+import { GzipInput, validateGzipBufferTail, validateGzipContainerTail } from "./archive-gzip-tail.js";
 import { ArchiveFormatError } from "./archive-errors.js";
 import { TarParserStream } from "./archive-tar-wasm.js";
+function* bufferChunks(buffer) {
+    for (let offset = 0; offset < buffer.length; offset += 65536)
+        yield buffer.subarray(offset, offset + 65536);
+}
 async function gzipFile(filePath) {
     const handle = await fs.promises.open(filePath, "r");
     try {
@@ -17,10 +21,14 @@ async function gzipFile(filePath) {
     }
 }
 async function withTarStream(params, consume) {
-    const gzip = await gzipFile(params.archivePath);
+    const buffer = params.archiveBuffer;
+    const gzip = buffer !== undefined ? buffer[0] === 31 && buffer[1] === 139 : await gzipFile(params.archivePath);
     const parser = new TarParserStream(params.limits, params.onMember);
-    const input = fs.createReadStream(params.archivePath, { highWaterMark: 65536 });
-    const decoder = gzip ? createGunzip() : undefined;
+    const input = buffer !== undefined
+        ? Readable.from(bufferChunks(buffer), { objectMode: false, highWaterMark: 65536 })
+        : fs.createReadStream(params.archivePath, { highWaterMark: 65536 });
+    // Match the WASM input window for buffered reads instead of emitting 16 KiB chunks.
+    const decoder = gzip ? createGunzip(buffer === undefined ? undefined : { chunkSize: 65536 }) : undefined;
     const gzipInput = decoder ? new GzipInput(decoder) : undefined;
     const destroy = (error) => {
         input.destroy(error);
@@ -42,8 +50,12 @@ async function withTarStream(params, consume) {
         const error = await settled;
         if (error)
             throw error;
-        if (gzipInput)
-            await validateGzipContainerTail(params.archivePath, gzipInput.tailOffset, params.signal);
+        if (gzipInput) {
+            if (buffer !== undefined)
+                await validateGzipBufferTail(buffer, gzipInput.tailOffset, params.signal);
+            else
+                await validateGzipContainerTail(params.archivePath, gzipInput.tailOffset, params.signal);
+        }
         return result;
     }
     finally {
@@ -57,7 +69,7 @@ export async function inspectTar(params) {
     });
 }
 /** Replay in physical order, retaining at most one decoded chunk. Every range
- * comes from complete admission of the immutable staged input. */
+ * comes from complete admission of the immutable input. */
 export async function replayTar(params) {
     await withTarStream(params, async (parser) => {
         const iterator = parser[Symbol.asyncIterator]();

package/dist/archive-tar-wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-wasm.d.ts","sourceRoot":"","sources":["../src/archive-tar-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAuClE,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,SAAS;IAER,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAD9D,OAAO,CAAC,GAAG,CAAkB;IAC7B,YAAY,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,aAAA,EAQjG;IACD,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAIH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAkB/F;IACQ,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAKjD;IACQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAKpF;CACF"}
+{"version":3,"file":"archive-tar-wasm.d.ts","sourceRoot":"","sources":["../src/archive-tar-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAyClE,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,SAAS;IAER,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAD9D,OAAO,CAAC,GAAG,CAAkB;IAC7B,YAAY,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,aAAA,EAQjG;IACD,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAIH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAkB/F;IACQ,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAKjD;IACQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAKpF;CACF"}