@openclaw/fs-safe 0.15.0 → 0.16.0

package/dist/pinned-write.js

@@ -1,32 +1,28 @@
 import { syncFileBestEffort } from "./file-sync.js";
-import { randomUUID } from "node:crypto";
+import { assertDarwinCreationAcl, privateFileMutationAssertion } from "./creation-darwin.js";
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { createFileHandle } from "./create.js";
+import { creationAdmissionFromParent } from "./creation-path.js";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard, inspectDirectoryIdentity } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { syncDirectoryBestEffort } from "./directory-durability.js";
-import { sameFileIdentity, sha256Hex } from "./file-identity.js";
+import { sha256Hex } from "./file-identity.js";
 import { withAsyncDirectoryGuards } from "./guarded-mutation.js";
 import { mkdirPathComponentsWithGuards } from "./guarded-mkdir.js";
 import { runPinnedWriteNative } from "./native-pinned-write.js";
 import { getNativeBinding } from "./native.js";
 import { validatePinnedOperationPayload } from "./pinned-operation.js";
-import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { cleanupPinnedFilePath } from "./replace-file-temp-owner.js";
+import { cleanupPinnedFilePath } from "./file-cleanup.js";
 import { withSidecarLock } from "./sidecar-lock.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-import { writeAllToFile } from "./write-file-handle.js";
+import { writePinnedInput } from "./pinned-write-input.js";
+import { assertPinnedWriteMode, preparePinnedWriteMode } from "./pinned-write-mode.js";
+import { runPinnedStagedWrite } from "./pinned-write-staged.js";
 import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
-import { writeCopyFileToFd } from "./copy-file-input.js";
-import { publishCopyStage } from "./publish-copy-stage.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
-function byteLength(input, encoding) {
-    return typeof input === "string"
-        ? Buffer.byteLength(input, encoding ?? "utf8")
-        : input.byteLength;
-}
 function assertSafeBasename(basename) {
     if (!basename ||
         basename === "." ||
@@ -37,24 +33,10 @@ function assertSafeBasename(basename) {
         throw new FsSafeError("invalid-path", "invalid target path");
     }
 }
-function assertWithinMaxBytes(bytes, maxBytes) {
-    if (maxBytes !== undefined && bytes > maxBytes) {
-        throw new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
-    }
-}
 function fastParentGuardDeopt(error) {
     return error instanceof FsSafeError &&
         (error.code === "path-mismatch" || error.code === "not-file");
 }
-async function writeStreamToHandle(stream, handle, maxBytes, assertBeforeMutation) {
-    let bytes = 0;
-    for await (const chunk of stream) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        bytes += buffer.byteLength;
-        assertWithinMaxBytes(bytes, maxBytes);
-        await writeAllToFile(handle, buffer, { assertBeforeMutation });
-    }
-}
 const PINNED_WRITE_SNAPSHOT_KEYS = [
     "rootPath", "relativeParentPath", "basename", "maxBytes", "rootIdentity",
 ];
@@ -142,6 +124,7 @@ export async function withPinnedWriteRenameIdentityLock(params, run) {
     }, run);
 }
 async function runPinnedWriteFallback(params) {
+    const verifyPosixMode = params.verifyPosixMode === true && process.platform !== "win32";
     const exactRoot = typeof params.rootIdentity?.dev === "bigint" && typeof params.rootIdentity.ino === "bigint"
         ? { dev: params.rootIdentity.dev, ino: params.rootIdentity.ino } : undefined;
     const mutationAdmission = params.mutationAdmission;
@@ -246,15 +229,19 @@ async function runPinnedWriteFallback(params) {
         }));
         await assertAsyncDirectoryGuard(parentGuard);
     }
-    if (params.overwrite === false && (params.input.kind === "buffer" ||
-        (params.input.kind === "stream" && !params.input.stageBeforePublish))) {
+    if (params.overwrite === false && params.input.kind !== "file" && !params.input.stageBeforePublish) {
         const assertBeforeMutation = () => {
             assertFinalSymlinkRejected(targetPath, params.rejectFinalSymlink);
             params.assertBeforeMutation?.();
         };
         const handle = await withAsyncDirectoryGuards([parentGuard], async () => {
             assertBeforeMutation();
-            return await fs.open(targetPath, fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL, params.mode);
+            if (params.private) {
+                return await createFileHandle(targetPath, {
+                    private: true, mode: 0o600, assertBeforeMutation,
+                }, creationAdmissionFromParent(parentGuard));
+            }
+            return await fs.open(targetPath, fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL, verifyPosixMode ? 0o600 : params.mode);
         }, {
             onPostGuardFailure: async (openedHandle) => {
                 // The parent failed verification, so targetPath may now resolve
@@ -267,19 +254,27 @@ async function runPinnedWriteFallback(params) {
         try {
             const verificationIdentity = fsSync.fstatSync(handle.fd, { bigint: true });
             createdIdentity = verificationIdentity;
-            if (params.input.kind === "buffer") {
-                assertWithinMaxBytes(byteLength(params.input.data, params.input.encoding), params.maxBytes);
-                await writeAllToFile(handle, params.input.data, {
-                    encoding: params.input.encoding, assertBeforeMutation,
-                });
-            }
-            else {
-                await writeStreamToHandle(params.input.stream, handle, params.maxBytes, assertBeforeMutation);
+            let assertBeforeWrite = params.private
+                ? privateFileMutationAssertion(handle.fd, assertBeforeMutation) : assertBeforeMutation;
+            if (verifyPosixMode) {
+                assertBeforeWrite = await preparePinnedWriteMode(handle, Number(createdIdentity.mode & 4095n), assertBeforeWrite);
+                assertPinnedWriteMode(handle.fd, 0o600);
             }
+            await writePinnedInput(handle, params.input, params.maxBytes, assertBeforeWrite);
+            if (verifyPosixMode)
+                assertPinnedWriteMode(handle.fd, 0o600);
+            if (params.private)
+                assertDarwinCreationAcl(handle.fd);
             // Content writes may clear set-ID bits; finalize them through the owned fd.
             await handle.chmod(params.mode);
-            if (params.sync !== false)
-                await syncFileBestEffort(handle);
+            if (verifyPosixMode)
+                assertPinnedWriteMode(handle.fd, params.mode);
+            if (params.sync !== false) {
+                if (params.strictFileSync)
+                    await handle.sync();
+                else
+                    await syncFileBestEffort(handle);
+            }
             const stat = fsSync.fstatSync(handle.fd);
             if (params.sync !== false)
                 await syncDirectoryBestEffort(parentPath);
@@ -299,110 +294,5 @@ async function runPinnedWriteFallback(params) {
             }
         }
     }
-    // Private staging must not consume the destination basename's filename budget.
-    const tempPath = path.join(parentPath, `.fs-safe-${randomUUID()}.tmp`);
-    const tempFlags = fsSync.constants.O_WRONLY |
-        fsSync.constants.O_CREAT |
-        fsSync.constants.O_EXCL |
-        (process.platform !== "win32" && "O_NOFOLLOW" in fsSync.constants
-            ? fsSync.constants.O_NOFOLLOW
-            : 0);
-    let handle;
-    let tempStat;
-    let tempIdentity;
-    let readHandle;
-    let renamed = false;
-    try {
-        params.assertBeforeMutation?.();
-        handle = await fs.open(tempPath, tempFlags, params.mode);
-        let verificationIdentity = fsSync.fstatSync(handle.fd, { bigint: true });
-        tempIdentity = verificationIdentity;
-        if (params.input.kind === "buffer") {
-            assertWithinMaxBytes(byteLength(params.input.data, params.input.encoding), params.maxBytes);
-            await writeAllToFile(handle, params.input.data, {
-                encoding: params.input.encoding, assertBeforeMutation: params.assertBeforeMutation,
-            });
-        }
-        else if (params.input.kind === "file") {
-            await writeCopyFileToFd(handle.fd, params.input, params.maxBytes, params.assertBeforeMutation);
-        }
-        else {
-            await writeStreamToHandle(params.input.stream, handle, params.maxBytes, params.assertBeforeMutation);
-        }
-        tempStat = fsSync.fstatSync(handle.fd);
-        const tempPathStat = fsSync.lstatSync(tempPath);
-        if (tempPathStat.isSymbolicLink() || !sameFileIdentity(tempPathStat, tempStat)) {
-            throw new FsSafeError("path-mismatch", "fallback temp path changed during write");
-        }
-        const expectedTempStat = tempStat;
-        await handle.chmod(params.mode);
-        if (params.sync !== false)
-            await syncFileBestEffort(handle);
-        if (params.input.kind === "file")
-            await params.input.verifySource();
-        let verifiedIdentity = expectedTempStat;
-        await withAsyncDirectoryGuards([parentGuard], async () => {
-            assertFinalSymlinkRejected(targetPath, params.rejectFinalSymlink);
-            if (params.overwrite === false) {
-                publishCopyStage({
-                    temporaryPath: tempPath, targetPath, fd: handle.fd,
-                    identity: tempIdentity, parentGuard,
-                    assertBeforeMutation: params.assertBeforeMutation,
-                    onPublished: (identity) => {
-                        renamed = true;
-                        params.onPublished?.(identity);
-                    },
-                });
-            }
-            else {
-                params.assertBeforeMutation?.();
-                await fs.rename(tempPath, targetPath);
-                renamed = true;
-                params.onPublished?.(verificationIdentity);
-            }
-            await getFsSafeTestHooks()?.afterPinnedWriteFallbackRename?.(targetPath);
-            if (params.sync !== false)
-                await syncDirectoryBestEffort(parentPath);
-            const targetStat = fsSync.lstatSync(targetPath);
-            if (targetStat.isSymbolicLink()) {
-                throw new FsSafeError("path-mismatch", "fallback target changed during write");
-            }
-            if (!sameFileIdentity(targetStat, expectedTempStat)) {
-                // On filesystems like rclone FUSE, rename(2) can give the destination a
-                // different inode from the source temp fd even with zero concurrency. The
-                // caller must ensure mutual exclusion before passing "verify-content";
-                // fall back to a content hash for this rename-boundary check only.
-                if (params.onRenameIdentityMismatch !== "verify-content") {
-                    throw new FsSafeError("path-mismatch", "fallback target changed during write");
-                }
-                if (params.input.kind !== "buffer") {
-                    throw new FsSafeError("path-mismatch", "fallback target changed during write");
-                }
-                const expectedHash = sha256Hex(params.input.data, params.input.encoding);
-                readHandle = await fs.open(targetPath, resolveReadOpenFlags());
-                const readHandleStat = fsSync.fstatSync(readHandle.fd, { bigint: true });
-                const actualHash = sha256Hex(await readHandle.readFile());
-                if (actualHash !== expectedHash) {
-                    throw new FsSafeError("path-mismatch", "fallback target changed during write");
-                }
-                // The content-verified destination, not the old temp inode, is now pinned.
-                verificationIdentity = readHandleStat;
-                // Preserve the helper's legacy numeric return facts, not the private proof.
-                verifiedIdentity = { dev: Number(readHandleStat.dev), ino: Number(readHandleStat.ino) };
-            }
-        });
-        await params.verifyPublished?.((readHandle ?? handle).fd, verificationIdentity, parentGuard);
-        return { dev: verifiedIdentity.dev, ino: verifiedIdentity.ino };
-    }
-    finally {
-        try {
-            if (!renamed && handle) {
-                await cleanupPinnedFilePath({ pathname: tempPath, handle, identity: tempIdentity, parentGuard });
-            }
-        }
-        finally {
-            await readHandle?.close().catch(() => undefined);
-            await handle?.close().catch(() => undefined);
-        }
-    }
+    return await runPinnedStagedWrite(params, parentPath, parentGuard);
 }

package/dist/private-directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private-directory.d.ts","sourceRoot":"","sources":["../src/private-directory.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,6BAA6B,GACtC,OAAO,CAAC,IAAI,CAAC,CAyBf"}
+{"version":3,"file":"private-directory.d.ts","sourceRoot":"","sources":["../src/private-directory.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,6BAA6B,GACtC,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/private-directory.js

@@ -1,6 +1,10 @@
+import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { warnNativeFallback } from "./native-fallback-warning.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { createPrivateWindowsDirectoryCommand } from "./windows-security-command.js";
 export async function createPrivateDirectory(targetPath, options) {
     const platform = options?.platform ?? process.platform;
     if (platform !== "win32") {
@@ -8,9 +12,19 @@ export async function createPrivateDirectory(targetPath, options) {
     }
     assertNoWindowsPathAlias(targetPath, "filesystem", "private directory path uses a Windows filesystem namespace alias", platform);
     const native = getNativeBinding();
-    if (!native) {
-        throw new FsSafeError("helper-unavailable", "private Windows directory creation requires the matching optional native platform package; " +
-            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    if (typeof native?.createPrivateDirectory === "function") {
+        native.createPrivateDirectory(targetPath);
+        return;
     }
-    native.createPrivateDirectory(targetPath);
+    if (getFsSafeNativeConfig().mode === "require") {
+        throw new FsSafeError("helper-unavailable", "private Windows directory creation requires an up-to-date native helper");
+    }
+    // Preserve the native parser's raw component restrictions before resolve()
+    // could discard dot components or Win32 could trim trailing aliases.
+    const components = targetPath.replaceAll("/", "\\").split("\\");
+    if (components.some(component => component.endsWith(".") || component.endsWith(" "))) {
+        throw Object.assign(new Error("private directory path has an ambiguous component"), { code: "EINVAL" });
+    }
+    warnNativeFallback("windows-private-directory", "Private Windows directory creation uses a slower built-in system command.");
+    await createPrivateWindowsDirectoryCommand(path.win32.resolve(targetPath));
 }

package/dist/private-producer-handoff-sync.d.ts

@@ -0,0 +1,14 @@
+import { type BigIntStats } from "node:fs";
+import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
+export declare function handoffCreatedFileSync(params: {
+    source: OwnedFileDescriptorSync;
+    sourcePath: string;
+    targetPath: string;
+    identity: BigIntStats;
+    assertSourceParent: () => void;
+    assertTargetParent: () => void;
+    assertBeforeMutation?: () => void;
+    verifyDescriptor?: (fd: number, path: string, links: number) => void;
+    onPublished?: () => void;
+}): OwnedFileDescriptorSync;
+//# sourceMappingURL=private-producer-handoff-sync.d.ts.map

package/dist/private-producer-handoff-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private-producer-handoff-sync.d.ts","sourceRoot":"","sources":["../src/private-producer-handoff-sync.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAyB,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAW7F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,MAAM,EAAE,uBAAuB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;IACtB,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;IAClC,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1B,GAAG,uBAAuB,CA0H1B"}

package/dist/private-producer-handoff-sync.js

@@ -0,0 +1,114 @@
+import fs, {} from "node:fs";
+import { ownFileDescriptorSync } from "./create-owned-file.js";
+import { FsSafeError } from "./errors.js";
+import { assertSynchronousCallbackResult } from "./mutation-authority.js";
+import { assertInitialSource, assertParents, inspectLinkedFile, normalizeLinkError, } from "./private-producer-handoff.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+export function handoffCreatedFileSync(params) {
+    let retained = params.source;
+    const owners = new Set([retained]);
+    const failures = [];
+    let publication = "not-published";
+    let cleanup = "preserved";
+    let closeFailed = false;
+    function close(owner) {
+        // A throwing close may already have released the descriptor for reuse.
+        owners.delete(owner);
+        try {
+            owner.close();
+        }
+        catch (error) {
+            closeFailed = true;
+            throw error;
+        }
+    }
+    function assertIdentityCurrent(owner, links) {
+        assertParents(params);
+        inspectLinkedFile(() => fs.fstatSync(owner.fd, { bigint: true }), params.identity, links, "created file descriptor");
+        if (cleanup !== "removed") {
+            inspectLinkedFile(() => fs.lstatSync(params.sourcePath, { bigint: true }), params.identity, links, "created file stage");
+        }
+        if (publication === "published") {
+            inspectLinkedFile(() => fs.lstatSync(params.targetPath, { bigint: true }), params.identity, links, "created file destination");
+        }
+    }
+    function verifyCurrent(owner, descriptorPath, links) {
+        assertIdentityCurrent(owner, links);
+        params.verifyDescriptor?.(owner.fd, descriptorPath, Number(links));
+    }
+    try {
+        assertInitialSource(params.identity);
+        verifyCurrent(retained, params.sourcePath, 1n);
+        assertSynchronousCallbackResult(params.assertBeforeMutation?.(), "assertBeforeMutation");
+        assertIdentityCurrent(retained, 1n);
+        publication = "indeterminate";
+        try {
+            fs.linkSync(params.sourcePath, params.targetPath);
+        }
+        catch (error) {
+            const normalized = normalizeLinkError(error);
+            if (normalized instanceof FsSafeError &&
+                (normalized.code === "already-exists" || normalized.code === "helper-unavailable")) {
+                publication = "not-published";
+            }
+            throw normalized;
+        }
+        publication = "published";
+        try {
+            params.onPublished?.();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (process.platform === "win32") {
+            verifyCurrent(retained, params.sourcePath, 2n);
+            // Keep the original pin until a verified published-name pin exists, so
+            // Windows can retire the staging name without leaving it delete-pending.
+            const sibling = ownFileDescriptorSync(fs.openSync(params.targetPath, fs.constants.O_RDWR | resolveReadOpenFlags()));
+            owners.add(sibling);
+            verifyCurrent(sibling, params.targetPath, 2n);
+            inspectLinkedFile(() => fs.fstatSync(retained.fd, { bigint: true }), params.identity, 2n, "created file descriptor");
+            close(retained);
+            retained = sibling;
+        }
+        const descriptorPath = process.platform === "win32" ? params.targetPath : params.sourcePath;
+        verifyCurrent(retained, descriptorPath, 2n);
+        assertSynchronousCallbackResult(params.assertBeforeMutation?.(), "assertBeforeMutation");
+        assertIdentityCurrent(retained, 2n);
+        cleanup = "failed";
+        // Link and unlink stay in one JS turn. Only the verified stage is removed;
+        // publication has committed and the destination is never rollback cleanup.
+        fs.unlinkSync(params.sourcePath);
+        cleanup = "removed";
+        verifyCurrent(retained, params.targetPath, 1n);
+    }
+    catch (error) {
+        failures.push(error);
+    }
+    if (failures.length === 0)
+        return retained;
+    for (const owner of owners) {
+        try {
+            close(owner);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    const primary = failures[0];
+    // Collision-as-no-op callers must still observe a failed settlement.
+    const code = closeFailed || failures.length > 1
+        ? "helper-failed"
+        : primary instanceof FsSafeError ? primary.code : "helper-failed";
+    throw new FsSafeError(code, "created file publication failed", {
+        cause: failures.length === 1 ? primary : new AggregateError(failures, "created file publication and settlement failed"),
+        details: {
+            publication: { status: publication },
+            cleanup,
+            resources: closeFailed ? "close-failed" : "closed",
+            path: params.targetPath,
+            dev: params.identity.dev,
+            ino: params.identity.ino,
+        },
+    });
+}

package/dist/private-producer-handoff.d.ts

@@ -6,11 +6,29 @@ export type PrivateProducerHandoff = {
     identity: BigIntStats;
     unregister: TempPathRegistration;
 };
-export declare function handoffPrivateProducerFile(params: {
-    sourcePath: string;
-    targetPath: string;
+type HandoffParents = {
     assertSourceParent: () => void;
     assertTargetParent: () => void;
+};
+type HandoffPaths = HandoffParents & {
+    sourcePath: string;
+    targetPath: string;
+};
+type ProducerHandoffParams = HandoffPaths & {
     readWrite: boolean;
-}): Promise<PrivateProducerHandoff>;
+};
+type CreatedHandoffParams = HandoffPaths & {
+    source: FileHandle;
+    identity: BigIntStats;
+    assertBeforeMutation?: () => void;
+    verifyDescriptor?: (fd: number, path: string, links: number) => Promise<void>;
+    onPublished?: () => void;
+};
+export declare function assertInitialSource(stat: BigIntStats): void;
+export declare function inspectLinkedFile(inspect: () => BigIntStats, expected: BigIntStats, links: bigint, label: string): BigIntStats;
+export declare function assertParents(params: HandoffParents): void;
+export declare function normalizeLinkError(error: unknown): unknown;
+export declare function handoffPrivateProducerFile(params: ProducerHandoffParams): Promise<PrivateProducerHandoff>;
+export declare function handoffCreatedFile(params: CreatedHandoffParams): Promise<FileHandle>;
+export {};
 //# sourceMappingURL=private-producer-handoff.d.ts.map

package/dist/private-producer-handoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private-producer-handoff.d.ts","sourceRoot":"","sources":["../src/private-producer-handoff.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAW,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKvD,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CAClC,CAAC;AA2OF,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,SAAS,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA6HlC"}
+{"version":3,"file":"private-producer-handoff.d.ts","sourceRoot":"","sources":["../src/private-producer-handoff.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAW,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMvD,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CAClC,CAAC;AASF,KAAK,cAAc,GAAG;IACpB,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,kBAAkB,EAAE,MAAM,IAAI,CAAC;CAChC,CAAC;AAEF,KAAK,YAAY,GAAG,cAAc,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAChF,KAAK,qBAAqB,GAAG,YAAY,GAAG;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC;AACnE,KAAK,oBAAoB,GAAG,YAAY,GAAG;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;IAClC,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC;AAMF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAU3D;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,WAAW,EAC1B,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,WAAW,CAQb;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAG1D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAmB1D;AAiUD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAEzG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,CAEpF"}