@openclaw/fs-safe 0.12.0 → 0.13.1

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":"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;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,CA8CrB"}
+{"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"}

package/dist/archive-zip-names.js

@@ -41,7 +41,10 @@ function utf8(bytes) {
         return zipFormat("invalid UTF-8 name");
     }
 }
-function key(name) {
+// Canonical identity only; this does not replace raw path validation.
+export function zipPathKey(name) {
+    if (name && name !== "." && !name.includes("/") && !name.includes("\\"))
+        return name;
     return stripArchivePath(name, 0) ?? "";
 }
 function originalName(name, rawName, flags) {
@@ -87,31 +90,49 @@ export function admitZipNames(params) {
         (centralField === localField ||
             (centralField !== undefined && localField !== undefined && centralField.equals(localField)));
     const localUnicode = sameName && sameUnicode ? centralUnicode : unicodeName(local, localExtra);
-    const centralKey = key(centralRaw);
-    if (!sameName && centralKey !== key(localRaw)) {
+    const centralKey = zipPathKey(centralRaw);
+    if (!sameName && centralKey !== zipPathKey(localRaw)) {
         zipFormat("central and local names disagree");
     }
     const interpretations = [centralUtf8, localUtf8, centralUnicode, localUnicode].filter((value) => value !== undefined);
-    const interpretationKey = interpretations.length ? key(interpretations[0]) : undefined;
-    if (interpretations.some((value) => value !== interpretations[0] && key(value) !== interpretationKey)) {
+    // Canonical paths erase terminal separators. Preserve their kind meaning in
+    // every interpretation, including Unicode overrides of legacy-encoded names.
+    const directory = /[/\\]$/.test(centralRaw);
+    if (/[/\\]$/.test(localRaw) !== directory ||
+        interpretations.some((value) => /[/\\]$/.test(value) !== directory)) {
+        zipFormat("conflicting terminal directory markers");
+    }
+    const interpretationKey = interpretations.length ? zipPathKey(interpretations[0]) : undefined;
+    if (interpretations.some((value) => value !== interpretations[0] && zipPathKey(value) !== interpretationKey)) {
         zipFormat("conflicting Unicode name interpretations");
     }
     // JSZip checks the central Unicode field against the local name. A slash-only
     // spelling difference must not make one decoder ignore a meaningful override.
     if (centralUnicode && !central.equals(local) &&
-        key(centralUnicode) !== key(local.toString("utf8"))) {
+        zipPathKey(centralUnicode) !== zipPathKey(local.toString("utf8"))) {
         zipFormat("Unicode override disagrees with local decoder name");
     }
-    if (!centralUnicode && localUnicode && key(localUnicode) !== key(local.toString("utf8"))) {
+    if (!centralUnicode && localUnicode && zipPathKey(localUnicode) !== zipPathKey(local.toString("utf8"))) {
         zipFormat("local-only Unicode override changes the name");
     }
-    const identities = new Set([centralKey]);
-    if (centralUnicode !== undefined)
-        identities.add(key(Buffer.from(centralUnicode).toString("latin1")));
-    if ([...identities].some((identity) => seen.has(identity))) {
+    const unicodeKey = centralUnicode === undefined
+        ? undefined : zipPathKey(Buffer.from(centralUnicode).toString("latin1"));
+    if (seen.has(centralKey) ||
+        (unicodeKey !== undefined && unicodeKey !== centralKey && seen.has(unicodeKey))) {
         throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
     }
-    for (const identity of identities)
-        seen.add(identity);
-    return centralUnicode ?? centralUtf8 ?? (central.every((byte) => byte < 128) ? central.toString("ascii") : undefined);
+    seen.add(centralKey);
+    if (unicodeKey !== undefined && unicodeKey !== centralKey)
+        seen.add(unicodeKey);
+    const path = centralUnicode ?? centralUtf8 ?? (central.every((byte) => byte < 128) ? central.toString("ascii") : undefined);
+    const portablePath = centralUnicode ?? localUtf8 ?? (sameName && path !== undefined ? path : local.toString("utf8"));
+    // Reuse the admitted interpretation, never the Latin-1 Unicode collision key.
+    // Unflagged legacy names can decode differently and need their own key.
+    const portableKey = portablePath === centralRaw ? centralKey
+        : interpretations.includes(portablePath) ? interpretationKey : zipPathKey(portablePath);
+    return {
+        path,
+        portableKey,
+        directory,
+    };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC3F,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAO9B"}
+{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE3F,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAQ9B"}

package/dist/archive-zip-preflight.js

@@ -7,6 +7,7 @@ export async function loadZipArchiveWithPreflight(buffer, limits) {
     if (buffer.byteLength > resolvedLimits.maxArchiveBytes) {
         throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
     }
-    const entryCount = admitZipBuffer(buffer, resolvedLimits);
-    return await loadAdmittedZipArchive(buffer, entryCount);
+    const entries = [];
+    admitZipBuffer(buffer, resolvedLimits, entry => { entries.push(entry); });
+    return await loadAdmittedZipArchive(buffer, entries);
 }

package/dist/archive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACjF,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpH,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,6BAA6B,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,iCAAiC,EACjC,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AAiNpC,wBAAsB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CjF"}
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAIlE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACjF,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpH,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,6BAA6B,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,iCAAiC,EACjC,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AAiNpC,wBAAsB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDjF"}

package/dist/archive.js

@@ -22,6 +22,7 @@ import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { getNativeBinding } from "./native.js";
 import { resolveArchiveFilteredEntryPolicy, shouldExtractArchiveEntry, } from "./archive-policy.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { realpathSync } from "./realpath.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
@@ -51,7 +52,7 @@ function resolveZipOutputPath(params) {
     const canonicalPath = stripArchivePath(params.entryPath, 0);
     if (!canonicalPath)
         return null;
-    const relPath = stripArchivePath(canonicalPath, params.strip);
+    const relPath = params.strip === 0 ? canonicalPath : stripArchivePath(canonicalPath, params.strip);
     if (!relPath) {
         return null;
     }
@@ -203,19 +204,23 @@ async function extractZip(params) {
     }
 }
 export async function extractArchive(params) {
+    const archivePath = params.archivePath;
+    const destDir = params.destDir;
     const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
-    const kind = params.kind ?? resolveArchiveKind(params.archivePath);
+    const kind = params.kind ?? resolveArchiveKind(archivePath);
     if (!kind) {
-        throw new Error(`unsupported archive: ${params.archivePath}`);
+        throw new Error(`unsupported archive: ${archivePath}`);
     }
     const label = kind === "zip" ? "extract zip" : "extract tar";
     const limits = resolveExtractLimits(params.limits);
     const tarLimits = resolveTarMeterLimits(limits);
     const native = getNativeBinding();
+    assertNoWindowsPathAlias(archivePath, "filesystem", "archive source uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(destDir, "filesystem", "archive destination uses a Windows filesystem namespace alias");
     // Read the declared public fields before private adapters copy options: class
     // getters and inherited policy must survive identically on every backend.
     const options = {
-        archivePath: params.archivePath, destDir: params.destDir,
+        archivePath, destDir,
         durable: params.durable,
         stripComponents: params.stripComponents, limits,
         entryModes: params.entryModes, entryFilter: params.entryFilter, onFiltered,

package/dist/copy-file-input.d.ts

@@ -2,7 +2,7 @@ import { type BigIntStats } from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 import { type CopyCloneMode } from "./copy-policy.js";
 import { type NativeBinding } from "./native.js";
-import type { NativeFileCopyResult } from "./native-binding.js";
+import { type NativeFileCopyResult } from "./native-binding.js";
 export type CopyFileInput = {
     kind: "file";
     handle: FileHandle;

package/dist/copy-file-input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy-file-input.d.ts","sourceRoot":"","sources":["../src/copy-file-input.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE5E,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAIhE,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,aAAa,CAM5E;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAChD,QAAQ,EAAE,WAAW,GACpB,OAAO,CAAC,IAAI,CAAC,CASf;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,aAAa,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA8B3C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAWnG"}
+{"version":3,"file":"copy-file-input.d.ts","sourceRoot":"","sources":["../src/copy-file-input.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE5E,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAwB,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAItF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,aAAa,CAM5E;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAChD,QAAQ,EAAE,WAAW,GACpB,OAAO,CAAC,IAAI,CAAC,CASf;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,aAAa,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA+B3C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAWnG"}

package/dist/copy-file-input.js

@@ -2,6 +2,7 @@ import fs, {} from "node:fs";
 import { resolveCopyCloneMode } from "./copy-policy.js";
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { transferFileHandle } from "./file-handle-transfer.js";
 export function resolveFileCopyCloneMode(mode) {
@@ -34,6 +35,7 @@ export async function createNativeCopyFile(native, input, parentFd, basename, ma
         }
         return undefined;
     }
+    captureNativeFdClose(native);
     const nativeSignal = input.signal ? AbortSignal.any([input.signal]) : undefined;
     try {
         // The caller adopts this descriptor before observing a later cancellation.

package/dist/darwin-acl.d.ts

@@ -0,0 +1,4 @@
+import type { NativeDarwinAclFacts } from "./native-binding.js";
+/** Internal descriptor facts only; callers own identity, lifetime, and ACL policy. */
+export declare function inspectDarwinAcl(fd: number): NativeDarwinAclFacts;
+//# sourceMappingURL=darwin-acl.d.ts.map

package/dist/darwin-acl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"darwin-acl.d.ts","sourceRoot":"","sources":["../src/darwin-acl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,CAmBjE"}

package/dist/darwin-acl.js

@@ -0,0 +1,24 @@
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+/** Internal descriptor facts only; callers own identity, lifetime, and ACL policy. */
+export function inspectDarwinAcl(fd) {
+    if (!Number.isInteger(fd) || fd < 0 || fd > 0x7fff_ffff) {
+        throw new FsSafeError("permission-unverified", "Darwin ACL inspection requires a valid descriptor");
+    }
+    const native = getNativeBinding();
+    if (typeof native?.inspectDarwinAcl !== "function") {
+        throw new FsSafeError("helper-unavailable", "Darwin ACL inspection requires the matching native capability");
+    }
+    let facts;
+    try {
+        facts = native.inspectDarwinAcl(fd);
+    }
+    catch (cause) {
+        throw new FsSafeError("permission-unverified", "Darwin descriptor ACL could not be inspected", { cause });
+    }
+    const state = facts && typeof facts === "object" && "state" in facts ? facts.state : undefined;
+    if (state !== "absent" && state !== "empty" && state !== "present") {
+        throw new FsSafeError("permission-unverified", "Darwin ACL inspection returned invalid facts");
+    }
+    return { state };
+}

package/dist/deny-mutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deny-mutations.d.ts","sourceRoot":"","sources":["../src/deny-mutations.ts"],"names":[],"mappings":"AAKA,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAI1F;AAMD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAqBF,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,UAAU,EAAE,kBAAkB,GAAG,SAAS,GACzC,kBAAkB,GAAG,SAAS,CAWhC"}
+{"version":3,"file":"deny-mutations.d.ts","sourceRoot":"","sources":["../src/deny-mutations.ts"],"names":[],"mappings":"AASA,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAQ1F;AAMD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAsBF,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,UAAU,EAAE,kBAAkB,GAAG,SAAS,GACzC,kBAAkB,GAAG,SAAS,CAWhC"}