@openclaw/fs-safe 0.11.0 → 0.13.0

package/dist/archive-native.js

@@ -1,14 +1,15 @@
 import { classifyArchiveParserError } from "./archive-parser-errors.js";
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
-import { ArchiveFormatError, ArchiveSecurityError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
-import { stripArchivePath, validateArchiveEntryPath } from "./archive-entry.js";
+import { ArchiveFormatError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
 import { createArchiveEntryPlanner } from "./archive-plan.js";
 import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
 import { prepareArchiveDestinationGuard, withStagedArchiveDestination, } from "./archive-staging.js";
 import { mergePlannedArchiveIntoDestination } from "./archive-merge.js";
 import { admitZipFile } from "./archive-zip-admission.js";
+import { validateNativeZipManifest } from "./archive-zip-manifest.js";
 export function throwMappedNativeArchiveError(error) {
     if (error instanceof Error) {
         const mapped = classifyArchiveParserError(error.message, { cause: error });
@@ -32,9 +33,9 @@ export async function extractNativeArchive(params) {
     });
     try {
         const zipEntries = [];
-        const physicalCount = params.kind === "zip"
-            ? await admitZipFile(stagedArchive.path, limits, params.deadline, (entry) => { zipEntries.push(entry); })
-            : undefined;
+        if (params.kind === "zip") {
+            await admitZipFile(stagedArchive.path, limits, params.deadline, (entry) => { zipEntries.push(entry); });
+        }
         const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
         const destinationRealDir = destinationGuard.realPath;
         await withStagedArchiveDestination({
@@ -47,21 +48,8 @@ export async function extractNativeArchive(params) {
                     .catch(throwMappedNativeArchiveError);
                 params.deadline.check();
                 assertArchiveEntryCountWithinLimit(manifest.length, limits);
-                if (physicalCount !== undefined && manifest.length !== physicalCount) {
-                    throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
-                }
                 if (params.kind === "zip") {
-                    for (const [ordinal, entry] of manifest.entries()) {
-                        const physical = zipEntries[ordinal];
-                        // Native ZIP indices are physical central-directory ordinals. Legacy
-                        // filename decoding remains native-selected; compare names when known.
-                        if (!physical || physical.index !== ordinal || entry.index !== ordinal ||
-                            entry.size !== physical.size ||
-                            (physical.path !== undefined && stripArchivePath(entry.path, 0) !== stripArchivePath(physical.path, 0)) ||
-                            (physical.creatorSystem === 3 && entry.mode !== physical.externalAttributes >>> 16)) {
-                            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
-                        }
-                    }
+                    validateNativeZipManifest(manifest, zipEntries);
                 }
                 // Recheck the native manifest at the shared policy boundary before
                 // any caller callback observes an entry.

package/dist/archive-plan.js

@@ -17,7 +17,7 @@ export function createArchiveEntryPlanner(params, archiveKind) {
         const canonicalPath = stripArchivePath(entry.path, 0);
         if (!canonicalPath)
             return null;
-        const relPath = stripArchivePath(canonicalPath, strip);
+        const relPath = strip === 0 ? canonicalPath : stripArchivePath(canonicalPath, strip);
         if (!relPath)
             return null;
         validateArchiveEntryPath(relPath, { escapeLabel: params.escapeLabel });

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

@@ -1 +1 @@
-{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAeA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAyOpG,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"}
+{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA0OpG,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 { Readable, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { readBoundedAsync } from "./bounded-read.js";
 import { ArchiveFormatError, ArchiveSecurityError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
 import { formatErrorDetail } from "./error-detail.js";
@@ -18,7 +19,9 @@ import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { realpathSync } from "./realpath.js";
 import { getNativeBinding } from "./native.js";
 import { admitZipBuffer } from "./archive-zip-admission.js";
+import { validateNativeZipManifest } from "./archive-zip-manifest.js";
 import { resolveExtractLimits, resolveTarMeterLimits } from "./archive-limits.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 const ZIP_UNIX_FILE_TYPE_MASK = 0o170000;
 const ZIP_UNIX_SYMLINK_TYPE = 0o120000;
 function canonicalEntryPath(entryPath) {
@@ -32,40 +35,26 @@ function normalizedRequestedEntry(entryPath) {
     }
     return normalized;
 }
-async function readStreamBounded(stream, maxBytes) {
-    if (!(Symbol.asyncIterator in Object(stream))) {
-        return await new Promise((resolve, reject) => {
-            const readable = stream;
-            const chunks = [];
-            let total = 0;
-            readable.on("data", (chunk) => {
-                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                total += buffer.length;
-                if (total > maxBytes) {
-                    readable.pause();
-                    reject(new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT));
-                    return;
-                }
-                chunks.push(buffer);
-            });
-            readable.once("end", () => resolve(Buffer.concat(chunks, total)));
-            readable.once("error", reject);
-        });
-    }
-    const chunks = [];
+async function readAdmittedTarPayload(stream, size) {
+    // Complete admission has bounded this exact range. Copy as it arrives so
+    // decoder chunks can be released before the caller receives the owned result.
+    const result = Buffer.allocUnsafe(size);
     let total = 0;
     for await (const chunk of stream) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        total += buffer.length;
-        if (total > maxBytes) {
-            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT);
+        if (chunk.length > size - total) {
+            throw new ArchiveFormatError("invalid admitted TAR payload size");
         }
-        chunks.push(buffer);
+        chunk.copy(result, total);
+        total += chunk.length;
     }
-    return Buffer.concat(chunks, total);
+    if (total !== size)
+        throw new ArchiveFormatError("truncated admitted TAR range");
+    return result;
 }
 async function readArchiveInput(archivePath) {
+    assertNoWindowsPathAlias(archivePath);
     const resolved = realpathSync.native(archivePath);
+    assertNoWindowsPathAlias(resolved);
     const before = await inspectFileIdentity(async () => {
         const stat = fsSync.lstatSync(archivePath, { bigint: true });
         if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -104,8 +93,8 @@ async function readArchiveInput(archivePath) {
         await handle.close().catch(() => undefined);
     }
 }
-async function readZipEntry(buffer, entryPath, maxBytes, physicalCount) {
-    const archive = await loadAdmittedZipArchive(buffer, physicalCount);
+async function readZipEntry(buffer, entryPath, maxBytes, admitted) {
+    const archive = await loadAdmittedZipArchive(buffer, admitted);
     let entry;
     // JSZip keys retain some aliases and may use Unicode Path metadata. Scan the
     // effective entries once, after raw ZIP admission has rejected collisions.
@@ -124,12 +113,31 @@ async function readZipEntry(buffer, entryPath, maxBytes, physicalCount) {
         (entry.unixPermissions & ZIP_UNIX_FILE_TYPE_MASK) === ZIP_UNIX_SYMLINK_TYPE) {
         throw new Error(`archive entry is a link: ${formatErrorDetail(entryPath)}`);
     }
+    const integrity = createZipIntegrityTransform(entry);
     const stream = typeof entry.nodeStream === "function"
         ? entry.nodeStream()
         : Readable.from(await entry.async("nodebuffer"));
-    const integrity = createZipIntegrityTransform(entry);
-    stream.once("error", (error) => integrity.destroy(normalizeZipIntegrityError(error)));
-    return await readStreamBounded(stream.pipe(integrity), maxBytes);
+    const chunks = [];
+    let total = 0;
+    const destination = new Writable({
+        write(chunk, _encoding, callback) {
+            total += chunk.length;
+            if (total > maxBytes) {
+                callback(new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT));
+                return;
+            }
+            chunks.push(chunk);
+            callback();
+        },
+    });
+    try {
+        // Iterator teardown can mask limit errors on Node 22; keep them in stream callbacks.
+        await pipeline(stream, integrity, destination);
+        return Buffer.concat(chunks, total);
+    }
+    catch (error) {
+        throw normalizeZipIntegrityError(error);
+    }
 }
 async function readTarEntry(archiveBuffer, entryPath, maxBytes) {
     const seenPaths = new Set();
@@ -162,15 +170,12 @@ async function readTarEntry(archiveBuffer, entryPath, maxBytes) {
         return Buffer.from(archiveBuffer.subarray(selected.offset, end));
     }
     let result;
-    await replayTar({ archiveBuffer, limits, members: [selected], async consume(_member, payload) {
-            result = await readStreamBounded(payload, maxBytes);
+    await replayTar({ archiveBuffer, limits, members: [selected], async consume(member, payload) {
+            result = await readAdmittedTarPayload(payload, member.size);
         } });
     return result;
 }
-function selectNativeEntry(manifest, requested, displayPath, physicalCount) {
-    if (physicalCount !== undefined && manifest.length !== physicalCount) {
-        throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
-    }
+function selectNativeEntry(manifest, requested, displayPath) {
     const seen = new Set();
     let selected;
     for (const entry of manifest) {
@@ -199,14 +204,17 @@ function throwNativeReadError(error) {
     }
     throw error;
 }
-async function readNativeBufferEntry(native, buffer, kind, requested, displayPath, maxBytes, physicalCount) {
+async function readNativeBufferEntry(native, buffer, kind, requested, displayPath, maxBytes, zipEntries) {
     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);
+        const manifest = reader.entries;
+        if (kind === "zip")
+            validateNativeZipManifest(manifest, zipEntries);
+        const selected = selectNativeEntry(manifest, requested, displayPath);
         return await reader.readEntry(selected.index, maxBytes, AbortSignal.any([signal]));
     }
     catch (error) {
@@ -222,14 +230,15 @@ export async function readArchiveEntry(archivePath, entryPath, options) {
         throw new Error(`unsupported archive: ${archivePath}`);
     }
     const requestedEntry = normalizedRequestedEntry(entryPath);
+    assertNoWindowsPathAlias(archivePath, "filesystem", "archive source uses a Windows filesystem namespace alias");
     const buffer = await readArchiveInput(archivePath);
-    const physicalCount = kind === "zip"
-        ? admitZipBuffer(buffer, resolveExtractLimits())
-        : undefined;
+    const zipEntries = [];
+    if (kind === "zip")
+        admitZipBuffer(buffer, resolveExtractLimits(), entry => { zipEntries.push(entry); });
     const native = getNativeBinding();
     if (native)
-        return await readNativeBufferEntry(native, buffer, kind, requestedEntry, entryPath, options.maxBytes, physicalCount);
+        return await readNativeBufferEntry(native, buffer, kind, requestedEntry, entryPath, options.maxBytes, zipEntries);
     assertPortableArchiveKind(kind);
-    return kind === "zip" ? await readZipEntry(buffer, requestedEntry, options.maxBytes, physicalCount)
+    return kind === "zip" ? await readZipEntry(buffer, requestedEntry, options.maxBytes, zipEntries)
         : await readTarEntry(buffer, requestedEntry, options.maxBytes);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"archive-staging.d.ts","sourceRoot":"","sources":["../src/archive-staging.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAGnD,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;AAgB7B,MAAM,MAAM,qBAAqB,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;AAMrE,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS1F,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAS9F;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9F;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyCpG;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnF;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,qBAAqB,GACvC,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"}
+{"version":3,"file":"archive-staging.d.ts","sourceRoot":"","sources":["../src/archive-staging.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAGnD,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;AAiB7B,MAAM,MAAM,qBAAqB,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;AAMrE,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS1F,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAY9F;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9F;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA2CpG;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnF;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,CAmBhB;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;AAkBF,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,qBAAqB,GACvC,OAAO,CAAC,IAAI,CAAC,CAOf;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,CAiCb;AAED,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAEvE,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,MAAM,GAAG,oBAAoB,CAE7F"}

package/dist/archive-staging.js

@@ -14,6 +14,7 @@ import { mkdirPathComponentsWithGuards } from "./guarded-mkdir.js";
 import { expandRelativePathWithHome } from "./root-context.js";
 import { resolveRootPath } from "./root-path.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { realpathSync } from "./realpath.js";
 const ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK = "archive entry traverses symlink in destination";
 const ARCHIVE_STAGING_MODE = 0o700;
@@ -25,8 +26,11 @@ function symlinkTraversalError(originalPath) {
     return new ArchiveSecurityError("destination-symlink-traversal", `${ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK}: ${formatErrorDetail(originalPath)}`);
 }
 export async function createDirectoryIdentityGuard(dir) {
+    assertNoWindowsPathAlias(dir);
     try {
-        return await createAsyncDirectoryGuard(dir, { bigint: true });
+        const guard = await createAsyncDirectoryGuard(dir, { bigint: true });
+        assertNoWindowsPathAlias(guard.realPath);
+        return guard;
     }
     catch (err) {
         if (err instanceof FsSafeError && err.code === "not-file") {
@@ -47,6 +51,7 @@ export async function assertDirectoryIdentityGuard(guard) {
     }
 }
 export async function prepareArchiveDestinationGuard(destDir) {
+    assertNoWindowsPathAlias(destDir);
     let stat;
     try {
         stat = inspectFileIdentitySync(() => {
@@ -69,6 +74,7 @@ export async function prepareArchiveDestinationGuard(destDir) {
         throw err;
     }
     const realPath = realpathSync.native(destDir);
+    assertNoWindowsPathAlias(realPath);
     const guard = { dir: destDir, realPath, stat };
     try {
         inspectFileIdentitySync(() => fsSync.statSync(realPath, { bigint: true }), stat);
@@ -106,9 +112,14 @@ async function assertNoSymlinkTraversal(params) {
     }
 }
 export async function assertResolvedInsideDestination(params) {
+    const destinationRealDir = params.destinationRealDir;
+    const targetPath = params.targetPath;
+    const originalPath = params.originalPath;
+    assertNoWindowsPathAlias(destinationRealDir);
+    assertNoWindowsPathAlias(targetPath);
     let resolved;
     try {
-        resolved = realpathSync.native(params.targetPath);
+        resolved = realpathSync.native(targetPath);
     }
     catch (err) {
         if (isNotFoundPathError(err)) {
@@ -116,8 +127,9 @@ export async function assertResolvedInsideDestination(params) {
         }
         throw err;
     }
-    if (!isPathInside(params.destinationRealDir, resolved)) {
-        throw symlinkTraversalError(params.originalPath);
+    assertNoWindowsPathAlias(resolved);
+    if (!isPathInside(destinationRealDir, resolved)) {
+        throw symlinkTraversalError(originalPath);
     }
 }
 async function mkdirArchiveOutput(params) {
@@ -131,14 +143,28 @@ async function mkdirArchiveOutput(params) {
         throw error;
     }
 }
+function ownArchiveOutputPathParams(params) {
+    const deadline = params.deadline;
+    checkExtractionDeadline(deadline);
+    const destinationDir = params.destinationDir;
+    const destinationRealDir = params.destinationRealDir;
+    const relPath = params.relPath;
+    const outPath = params.outPath;
+    const originalPath = params.originalPath;
+    const isDirectory = params.isDirectory;
+    assertNoWindowsPathAlias(destinationDir);
+    assertNoWindowsPathAlias(destinationRealDir);
+    assertNoWindowsPathAlias(relPath, "relative");
+    assertNoWindowsPathAlias(outPath);
+    return { destinationDir, destinationRealDir, relPath, outPath, originalPath, isDirectory, deadline };
+}
 export async function prepareArchiveOutputPath(params) {
-    await prepareOutputPath(params);
+    await prepareOutputPath(ownArchiveOutputPathParams(params));
 }
 export async function preparePrivateArchiveOutputPath(params, assertGuards, destinationGuard) {
-    await prepareOutputPath(params, assertGuards, true, destinationGuard);
+    await prepareOutputPath(ownArchiveOutputPathParams(params), assertGuards, true, destinationGuard);
 }
 async function prepareOutputPath(params, assertGuards, privateWorkingMode = false, existingDestinationGuard) {
-    checkExtractionDeadline(params.deadline);
     const targetRoot = privateWorkingMode ? {
         async mkdir(relativePath) {
             // Retain Root.mkdir's strict alias admission before the shared traversal,
@@ -231,6 +257,7 @@ async function prepareOutputPath(params, assertGuards, privateWorkingMode = fals
     checkExtractionDeadline(params.deadline);
 }
 function assertSafeArchiveStagingPrefix(prefix) {
+    assertNoWindowsPathAlias(prefix, "relative");
     if (!prefix ||
         prefix === "." ||
         prefix === ".." ||
@@ -242,16 +269,22 @@ function assertSafeArchiveStagingPrefix(prefix) {
     return prefix;
 }
 export async function withStagedArchiveDestination(params) {
+    const destinationRealDir = params.destinationRealDir;
+    assertNoWindowsPathAlias(destinationRealDir);
     const stagingRoot = resolveSecureTempRoot({
         fallbackPrefix: "fs-safe-archive",
         unsafeFallbackLabel: "archive staging temp dir",
         warn: () => undefined,
     });
-    if (isPathInside(params.destinationRealDir, stagingRoot)) {
+    assertNoWindowsPathAlias(stagingRoot);
+    if (isPathInside(destinationRealDir, stagingRoot)) {
         throw new Error(`archive staging root must be outside destination: ${stagingRoot}`);
     }
-    const stagingPrefix = assertSafeArchiveStagingPrefix(params.stagingDirPrefix ?? "fs-safe-archive-");
-    const stagingDir = await fs.mkdtemp(path.join(stagingRoot, stagingPrefix));
+    const stagingDirPrefix = params.stagingDirPrefix;
+    const stagingPrefix = assertSafeArchiveStagingPrefix(stagingDirPrefix ?? "fs-safe-archive-");
+    const stagingPathPrefix = path.join(stagingRoot, stagingPrefix);
+    assertNoWindowsPathAlias(stagingPathPrefix);
+    const stagingDir = await fs.mkdtemp(stagingPathPrefix);
     const stagingGuard = await createDirectoryIdentityGuard(stagingDir);
     try {
         await fs.chmod(stagingDir, ARCHIVE_STAGING_MODE).catch(() => undefined);

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

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-inspect.d.ts","sourceRoot":"","sources":["../src/archive-tar-inspect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAOrF,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,qBAAqB,EAC/D,aAAa,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,CAAC,CAAC;AACzE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;AAE3F,2FAA2F;AAC3F,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CA2C/G"}
+{"version":3,"file":"archive-tar-inspect.d.ts","sourceRoot":"","sources":["../src/archive-tar-inspect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAQrF,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,qBAAqB,EAC/D,aAAa,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,CAAC,CAAC;AACzE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;AAE3F,2FAA2F;AAC3F,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CA6C/G"}

package/dist/archive-tar-inspect.js

@@ -8,14 +8,17 @@ import { resolveArchiveFilteredEntryPolicy } from "./archive-policy.js";
 import { createTarEntryPlanner } from "./archive-tar.js";
 import { inspectTar } from "./archive-tar-stream.js";
 import { getNativeBinding } from "./native.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 /** Complete TAR/gzip admission and zero-strip extraction policy, without output writes. */
 export async function inspectTarArchive(params) {
+    const archivePath = params.archivePath;
     const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
     const limits = resolveExtractLimits(params.limits);
     const tarLimits = resolveTarMeterLimits(limits);
     const native = getNativeBinding();
+    assertNoWindowsPathAlias(archivePath, "filesystem", "archive source uses a Windows filesystem namespace alias");
     return await withExtractionDeadline(params.timeoutMs, "inspect tar", async (deadline) => {
-        const staged = await stageArchiveFileForExtraction({ archivePath: params.archivePath, limits, deadline });
+        const staged = await stageArchiveFileForExtraction({ archivePath, limits, deadline });
         try {
             // Staging closes descriptors asynchronously; expiry there must not start a decoder.
             deadline.check();

package/dist/archive-zip-admission.d.ts

@@ -2,7 +2,7 @@ import type { ExtractionDeadline } from "./archive-deadline.js";
 import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
 import { type ZipDirectoryEntry } from "./archive-zip-directory.js";
 /** Admit physical records before a decoder can normalize or collapse names. */
-export declare function admitZipBuffer(input: Uint8Array, limits: ResolvedArchiveExtractLimits): number;
+export declare function admitZipBuffer(input: Uint8Array, limits: ResolvedArchiveExtractLimits, onEntry?: (entry: ZipDirectoryEntry) => void): number;
 /** The extraction input is private and immutable; read bounded metadata windows. */
 export declare function admitZipFile(archivePath: string, limits: ResolvedArchiveExtractLimits, deadline: ExtractionDeadline, onEntry?: (entry: ZipDirectoryEntry) => void): Promise<number>;
 //# sourceMappingURL=archive-zip-admission.d.ts.map

package/dist/archive-zip-admission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-admission.d.ts","sourceRoot":"","sources":["../src/archive-zip-admission.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAA+C,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAErH,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUtF,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,GAAG,MAAM,CAU9F;AAMD,oFAAoF;AACpF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EACvF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC,CA8DjB"}
+{"version":3,"file":"archive-zip-admission.d.ts","sourceRoot":"","sources":["../src/archive-zip-admission.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAA+C,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAErH,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUtF,+EAA+E;AAC/E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GACpG,MAAM,CAUR;AAMD,oFAAoF;AACpF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EACvF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC,CA8DjB"}

package/dist/archive-zip-admission.js

@@ -12,10 +12,10 @@ function checkSize(size, limits) {
         zipFormat("invalid archive size");
 }
 /** Admit physical records before a decoder can normalize or collapse names. */
-export function admitZipBuffer(input, limits) {
+export function admitZipBuffer(input, limits, onEntry) {
     checkSize(input.byteLength, limits);
     const buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
-    const scan = scanZipDirectory(buffer.length, limits);
+    const scan = scanZipDirectory(buffer.length, limits, onEntry);
     let step = scan.next();
     while (!step.done) {
         const { offset, length } = step.value;

package/dist/archive-zip-directory.d.ts

@@ -1,4 +1,5 @@
 import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+import type { ArchiveEntryKind } from "./archive-policy.js";
 export type ZipRead = {
     offset: number;
     length: number;
@@ -10,6 +11,8 @@ export type ZipDirectoryEntry = {
     externalAttributes: number;
     size: number;
     path?: string;
+    portableKey: string;
+    kind: ArchiveEntryKind;
 };
 export declare function scanZipDirectory(size: number, limits: ResolvedArchiveExtractLimits, onEntry?: (entry: ZipDirectoryEntry) => void): ZipScan;
 //# sourceMappingURL=archive-zip-directory.d.ts.map

package/dist/archive-zip-directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAmIF,wBAAiB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC/F,OAAO,CAkET"}
+{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AA4IF,wBAAiB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC/F,OAAO,CAmET"}

package/dist/archive-zip-directory.js

@@ -1,5 +1,15 @@
 import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
 import { admitZipNames, zipExtraFields, zipFormat, zipUInt64 } from "./archive-zip-names.js";
+function entryKind(attributes, directory) {
+    const type = (attributes >>> 16) & 0o170000;
+    // High-word symlinks remain links regardless of the creator or directory bits.
+    if (type === 0o120000)
+        return "symlink";
+    if ((attributes & 0x10) || type === 0o040000 || directory)
+        return "directory";
+    // Preserve the native decoder's rejection of unrecognized link-like types.
+    return (type & 0o120000) === 0o120000 ? "other" : "file";
+}
 function* read(offset, length, bound) {
     if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || length > bound - offset) {
         zipFormat("record outside archive bounds");
@@ -193,7 +203,7 @@ export function* scanZipDirectory(size, limits, onEntry) {
         const localExtraLength = local.readUInt16LE(28);
         const localNames = yield* read(localAt + 30, localNameLength + localExtraLength, directory.start);
         const localExtra = zipExtraFields(localNames.subarray(localNameLength));
-        const entryPath = admitZipNames({ central: centralName, local: localNames.subarray(0, localNameLength), flags, centralExtra, localExtra, seen });
+        const admittedName = admitZipNames({ central: centralName, local: localNames.subarray(0, localNameLength), flags, centralExtra, localExtra, seen });
         const localValues = wideValues(local, localExtra, false);
         const crc = central.readUInt32LE(16);
         if (!(flags & 8) && (local.readUInt32LE(14) !== crc || localValues.compressed !== values.compressed || localValues.uncompressed !== values.uncompressed)) {
@@ -213,7 +223,8 @@ export function* scanZipDirectory(size, limits, onEntry) {
         spans.push({ start: localAt, end: dataEnd });
         onEntry?.({
             index: count - 1, creatorSystem: central[5], externalAttributes: central.readUInt32LE(38),
-            size: values.uncompressed, path: entryPath,
+            size: values.uncompressed, path: admittedName.path, portableKey: admittedName.portableKey,
+            kind: entryKind(central.readUInt32LE(38), admittedName.directory),
         });
         at = next;
     }

package/dist/archive-zip-loader.d.ts

@@ -1,6 +1,7 @@
+import type { ZipDirectoryEntry } from "./archive-zip-directory.js";
 export type ZipArchiveWithFiles = {
     files: Record<string, unknown>;
 };
-/** Internal: the caller has admitted these unchanged bytes and their physical count. */
-export declare function loadAdmittedZipArchive(buffer: Buffer | Uint8Array, entryCount: number): Promise<ZipArchiveWithFiles>;
+/** Internal: the caller has admitted these unchanged bytes and their metadata. */
+export declare function loadAdmittedZipArchive(buffer: Buffer | Uint8Array, admitted: ZipDirectoryEntry[]): Promise<ZipArchiveWithFiles>;
 //# sourceMappingURL=archive-zip-loader.d.ts.map

package/dist/archive-zip-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-loader.d.ts","sourceRoot":"","sources":["../src/archive-zip-loader.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAMF,wFAAwF;AACxF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,mBAAmB,CAAC,CAoB9B"}
+{"version":3,"file":"archive-zip-loader.d.ts","sourceRoot":"","sources":["../src/archive-zip-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIpE,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAMF,kFAAkF;AAClF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CA6C9B"}

package/dist/archive-zip-loader.js

@@ -1,7 +1,9 @@
 import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
 import { validateArchiveEntryPath } from "./archive-entry.js";
-/** Internal: the caller has admitted these unchanged bytes and their physical count. */
-export async function loadAdmittedZipArchive(buffer, entryCount) {
+import { isZipSymlinkEntry } from "./archive-zip-entry.js";
+import { zipPathKey } from "./archive-zip-names.js";
+/** Internal: the caller has admitted these unchanged bytes and their metadata. */
+export async function loadAdmittedZipArchive(buffer, admitted) {
     const JSZip = await importOptionalJsZip();
     let archive;
     try {
@@ -11,11 +13,35 @@ export async function loadAdmittedZipArchive(buffer, entryCount) {
         throw new ArchiveFormatError(`invalid ZIP archive: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : undefined });
     }
     const names = Object.keys(archive.files);
-    if (names.length !== entryCount) {
+    if (names.length !== admitted.length) {
         throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
     }
-    for (const name of names)
+    // Object key order is not central-directory order (numeric names reorder).
+    // Use the admitted portable interpretation, including legacy UTF-8 decoding.
+    const physicalByPath = new Map();
+    for (const entry of admitted) {
+        physicalByPath.set(entry.portableKey, entry);
+    }
+    for (const name of names) {
         validateArchiveEntryPath(name);
+        const key = zipPathKey(name);
+        const physical = physicalByPath.get(key);
+        const entry = archive.files[name];
+        const entryName = entry.name;
+        let entryKey = key;
+        if (entryName !== name) {
+            validateArchiveEntryPath(entryName);
+            entryKey = zipPathKey(entryName);
+        }
+        const kind = isZipSymlinkEntry(entry) ? "symlink" : entry.dir ? "directory" : "file";
+        if (!physical || entryKey !== key || kind !== physical.kind) {
+            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+        }
+        physicalByPath.delete(key);
+    }
+    if (physicalByPath.size) {
+        throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+    }
     return archive;
 }
 async function importOptionalJsZip() {

package/dist/archive-zip-manifest.d.ts

@@ -0,0 +1,5 @@
+import type { NativeArchiveEntry } from "./native-binding.js";
+import type { ZipDirectoryEntry } from "./archive-zip-directory.js";
+/** Associate all native entries with physical admission before exposing any. */
+export declare function validateNativeZipManifest(manifest: NativeArchiveEntry[], admitted: ZipDirectoryEntry[]): void;
+//# sourceMappingURL=archive-zip-manifest.d.ts.map

package/dist/archive-zip-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-manifest.d.ts","sourceRoot":"","sources":["../src/archive-zip-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,gFAAgF;AAChF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,EAAE,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAC5D,IAAI,CAkBN"}

package/dist/archive-zip-manifest.js

@@ -0,0 +1,22 @@
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { stripArchivePath } from "./archive-entry.js";
+/** Associate all native entries with physical admission before exposing any. */
+export function validateNativeZipManifest(manifest, admitted) {
+    if (manifest.length !== admitted.length) {
+        throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
+    }
+    for (const [ordinal, entry] of manifest.entries()) {
+        const physical = admitted[ordinal];
+        const physicalPath = physical?.path;
+        const pathMatches = physicalPath === undefined || entry.path === physicalPath ||
+            stripArchivePath(entry.path, 0) === stripArchivePath(physicalPath, 0);
+        // Native indices are physical central-directory ordinals. Legacy name
+        // decoding remains native-selected; compare names when admission knows them.
+        if (!physical || physical.index !== ordinal || entry.index !== ordinal ||
+            entry.size !== physical.size || entry.kind !== physical.kind ||
+            !pathMatches ||
+            (physical.creatorSystem === 3 && entry.mode !== physical.externalAttributes >>> 16)) {
+            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+        }
+    }
+}

package/dist/archive-zip-names.d.ts

@@ -1,6 +1,7 @@
 export declare function zipFormat(message: string): never;
 export declare function zipUInt64(bytes: Buffer, offset: number): number;
 export declare function zipExtraFields(bytes: Buffer): Map<number, Buffer>;
+export declare function zipPathKey(name: string): string;
 export declare function admitZipNames(params: {
     central: Buffer;
     local: Buffer;
@@ -8,5 +9,9 @@ export declare function admitZipNames(params: {
     centralExtra: Map<number, Buffer>;
     localExtra: Map<number, Buffer>;
     seen: Set<string>;
-}): string | undefined;
+}): {
+    path?: string;
+    portableKey: string;
+    directory: boolean;
+};
 //# sourceMappingURL=archive-zip-names.d.ts.map

package/dist/archive-zip-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-names.d.ts","sourceRoot":"","sources":["../src/archive-zip-names.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE;AA+BD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC9C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB,GAAG,MAAM,GAAG,SAAS,CAiCrB"}
+{"version":3,"file":"archive-zip-names.d.ts","sourceRoot":"","sources":["../src/archive-zip-names.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE;AAUD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/C;AAoBD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC9C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAiE7D"}