@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/dist/source.d.ts

@@ -0,0 +1,28 @@
+export interface XmlSourceSpan {
+    readonly start: number;
+    readonly end: number;
+}
+/** Fill value before advancing. Streaming reads may be short; mark complete at EOF. */
+export interface XmlSourceRead {
+    readonly offset: number;
+    readonly length: number;
+    readonly streaming?: boolean;
+    value?: string;
+    complete?: boolean;
+}
+export type XmlSourceStep = number | XmlSourceRead;
+/** One fixed window; individual returned tokens still have their own size cost. */
+export declare class XmlSource {
+    private window;
+    private start;
+    private end;
+    private readonly streaming;
+    constructor(length: number | undefined);
+    get length(): number;
+    private load;
+    has(offset: number): Generator<XmlSourceStep, boolean, void>;
+    slice(start: number, end?: number): Generator<XmlSourceStep, string, void>;
+    charCodeAt(offset: number): Generator<XmlSourceStep, number, void>;
+    startsWith(value: string, offset: number): Generator<XmlSourceStep, boolean, void>;
+    indexOf(value: string, offset: number, end?: number): Generator<XmlSourceStep, number, void>;
+}

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/dist/source.js

@@ -0,0 +1,71 @@
+/** One fixed window; individual returned tokens still have their own size cost. */
+export class XmlSource {
+    window = '';
+    start = -1;
+    end;
+    streaming;
+    constructor(length) {
+        if (length !== undefined && (!Number.isSafeInteger(length) || length < 0))
+            throw new RangeError('Invalid XML source length');
+        this.streaming = length === undefined;
+        this.end = length ?? Infinity;
+    }
+    get length() { return this.end; }
+    *load(offset) {
+        if (offset >= this.end || offset >= this.start && offset < this.start + this.window.length)
+            return;
+        const start = this.streaming ? offset : Math.floor(offset / 4096) * 4096;
+        const request = { offset: start, length: Math.min(this.streaming ? 512 : 4096, this.end - start),
+            ...(this.streaming ? { streaming: true } : {}) };
+        yield request;
+        if (typeof request.value !== 'string' || request.value.length > request.length ||
+            (!this.streaming && request.value.length !== request.length) ||
+            (!request.value.length && !request.complete && this.streaming))
+            throw new TypeError('Incomplete XML source read');
+        if (this.streaming && request.complete)
+            this.end = start + request.value.length;
+        this.window = request.value;
+        this.start = start;
+    }
+    *has(offset) {
+        yield* this.load(offset);
+        return offset < this.end;
+    }
+    *slice(start, end = this.length) {
+        start = start < 0 ? Math.max(0, this.length + start) : Math.min(start, this.length);
+        end = end < 0 ? Math.max(0, this.length + end) : Math.min(end, this.length);
+        let result = '';
+        while (start < Math.min(end, this.length)) {
+            yield* this.load(start);
+            if (start >= this.end)
+                break;
+            const stop = Math.min(end, this.start + this.window.length);
+            result += this.window.slice(start - this.start, stop - this.start);
+            start = stop;
+        }
+        return result;
+    }
+    *charCodeAt(offset) {
+        return (yield* this.slice(offset, offset + 1)).charCodeAt(0);
+    }
+    *startsWith(value, offset) {
+        for (let index = 0; index < value.length; index++) {
+            if ((yield* this.charCodeAt(offset + index)) !== value.charCodeAt(index))
+                return false;
+        }
+        return true;
+    }
+    *indexOf(value, offset, end = Infinity) {
+        let tail = '';
+        while (offset < end && (yield* this.has(offset))) {
+            const stop = Math.min(end, this.start + this.window.length);
+            const part = tail + this.window.slice(offset - this.start, stop - this.start);
+            const found = part.indexOf(value);
+            if (found >= 0)
+                return offset - tail.length + found;
+            tail = value.length > 1 ? part.slice(-(value.length - 1)) : '';
+            offset = stop;
+        }
+        return -1;
+    }
+}

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/dist/stream.d.ts

@@ -0,0 +1,32 @@
+import type { XmlContent, XmlElement, XmlLimits, XmlName } from "./index.js";
+export type XmlStreamEvent = {
+    readonly type: "open" | "close";
+    readonly element: XmlElement;
+    readonly parent: XmlElement | undefined;
+} | {
+    readonly type: "content";
+    readonly continuation?: boolean;
+    readonly content: Exclude<XmlContent, XmlElement>;
+    readonly parent: XmlElement | undefined;
+};
+export interface XmlStreamLimits extends XmlLimits {
+    /** Validate the full document but return only its root name, without a retained tree. */
+    readonly retainTree?: boolean;
+    /** Ordered node events, awaited after each parser window. Requires retainTree:
+     * false; elements carry metadata without child/content arrays. Individual XML
+     * tokens remain resident until the underlying parser completes them. */
+    readonly events?: (event: XmlStreamEvent) => void | Promise<void>;
+    /** Detach selected non-root subtrees and await their consumer before parsing
+     * the next 512-unit window. By default nested matches belong to the selected ancestor. */
+    readonly streamElements?: {
+        /** Also detach preceding sibling content when selecting a subtree, before
+         * the parser advances. The final trailing content remains in the parent. */
+        readonly captureBefore?: boolean;
+        /** Detach nested matches too, consuming descendants before their ancestors. */
+        readonly includeNested?: boolean;
+        readonly matches: (element: XmlName, parent: XmlName | undefined, depth: number) => boolean;
+        readonly consume: (element: XmlElement, parent: XmlElement, before?: readonly XmlContent[]) => void | Promise<void>;
+    };
+}
+/** Incremental source consumption. Individual XML tokens and optional trees remain resident. */
+export declare function parseXmlStream(source: AsyncIterable<string> | Iterable<string>, limits?: XmlStreamLimits, checkpoint?: (units: number) => void | Promise<void>): Promise<XmlElement>;

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/dist/stream.js

@@ -0,0 +1,179 @@
+import { SaxesParser } from "saxes/saxes.js";
+import { XmlLimitError } from "./errors.js";
+/** Incremental source consumption. Individual XML tokens and optional trees remain resident. */
+export async function parseXmlStream(source, limits = {}, checkpoint) {
+    if (limits.recover)
+        throw new TypeError("XML stream recovery is unsupported; use parseXmlSteps");
+    for (const key of ["maxDepth", "maxNodes", "maxAttributes", "maxAttributesPerElement", "maxNamespaces", "maxContentNodes", "maxTextLength"]) {
+        const value = limits[key];
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 1))
+            throw new RangeError("XML limits must be positive integers");
+    }
+    const counters = { maxNodes: 0, maxAttributes: 0, maxContentNodes: 0, maxTextLength: 0 };
+    function bound(key, value) {
+        if (value > (limits[key] ?? Infinity))
+            throw new XmlLimitError(key, "XML resource limit exceeded");
+    }
+    function charge(key, value = 1) { counters[key] += value; bound(key, counters[key]); }
+    const retainContent = limits.retainContent !== false, tree = limits.retainTree !== false, retain = tree && retainContent;
+    const events = limits.events;
+    if (events && tree)
+        throw new TypeError("XML events require retainTree: false");
+    const describe = retain || !!events;
+    const queued = [];
+    const streaming = limits.streamElements;
+    if (streaming && !retain)
+        throw new TypeError("XML subtree streaming requires retained content and tree mode");
+    let selectedCount = 0;
+    const completed = [];
+    const stack = [];
+    const prolog = [], epilog = [];
+    const emptyNamespaces = new Map();
+    let root, declaration;
+    const parser = new SaxesParser({ xmlns: true, defaultXMLVersion: "1.0", forceXMLVersion: true });
+    parser.on("error", error => { throw new SyntaxError(`Invalid XML: ${error.message}`); });
+    parser.on("doctype", () => { throw new SyntaxError("Invalid XML: DTD and entity declarations are forbidden"); });
+    let prefix = "", capturing = describe;
+    parser.on("xmldecl", value => {
+        const encoding = value.encoding?.toUpperCase();
+        if (value.version !== "1.0" || encoding !== undefined &&
+            (!["UTF-8", "UTF-16", "UTF-16LE", "UTF-16BE"].includes(encoding) ||
+                limits.expectedEncoding !== undefined && encoding !== limits.expectedEncoding &&
+                    !(encoding === "UTF-16" && ["UTF-16LE", "UTF-16BE"].includes(limits.expectedEncoding))))
+            throw new SyntaxError("Invalid XML: unsupported XML declaration");
+        if (describe)
+            declaration = prefix.slice(0, prefix.indexOf("?>") + 2);
+        prefix = "";
+        capturing = false;
+    });
+    parser.on("opentag", tag => {
+        charge("maxNodes");
+        bound("maxDepth", stack.length + 1);
+        const attrs = Object.values(tag.attributes);
+        charge("maxAttributes", attrs.length);
+        bound("maxAttributesPerElement", attrs.length);
+        const parent = stack.at(-1);
+        let namespaces = parent?.namespaces ?? new Map([["xml", "http://www.w3.org/XML/1998/namespace"]]);
+        const bindings = Object.entries(tag.ns);
+        if (bindings.length) {
+            namespaces = new Map(namespaces);
+            for (const [name, uri] of bindings)
+                namespaces.set(name, uri);
+            bound("maxNamespaces", namespaces.size);
+        }
+        for (const attr of attrs)
+            charge("maxTextLength", attr.value.length);
+        const name = { name: tag.name, namespace: tag.uri, localName: tag.local };
+        limits.onElement?.(name, parent?.element, stack.length + 1);
+        const selected = (!selectedCount || streaming?.includeNested === true) && !!streaming?.matches(name, parent?.element, stack.length + 1);
+        if (selected && !parent)
+            throw new TypeError("XML subtree streaming cannot select the root");
+        let before = [];
+        if (selected) {
+            selectedCount++;
+            if (streaming?.captureBefore) {
+                before = parent.element.content.splice(0);
+                parent.element.children.length = 0;
+                parent.element.text = '';
+            }
+        }
+        charge("maxContentNodes", 1 + (retainContent || events ? attrs.length : 0));
+        const element = { kind: "element", ...name, children: [], content: [], text: "",
+            attributes: describe ? attrs.map(attr => ({ name: attr.name, localName: attr.local, namespace: attr.uri, value: attr.value })) : [],
+            namespaces: describe ? namespaces : emptyNamespaces,
+            ...(!root && describe ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
+        if (parent && tree && !selected) {
+            parent.element.children.push(element);
+            if (retain)
+                parent.element.content.push(element);
+        }
+        else if (!parent)
+            root = element;
+        stack.push({ element, namespaces, selected, before });
+        if (events)
+            queued.push({ type: "open", element, parent: parent?.element });
+    });
+    parser.on("closetag", () => {
+        const frame = stack.pop();
+        if (events)
+            queued.push({ type: "close", element: frame.element, parent: stack.at(-1)?.element });
+        if (frame.selected) {
+            completed.push({ element: frame.element, parent: stack.at(-1).element, before: frame.before });
+            selectedCount--;
+        }
+    });
+    async function drain() {
+        for (const entry of completed) {
+            await checkpoint?.(0);
+            await streaming.consume(entry.element, entry.parent, entry.before);
+        }
+        completed.length = 0;
+        for (const event of queued) {
+            await checkpoint?.(0);
+            await events(event);
+        }
+        queued.length = 0;
+    }
+    function append(content) {
+        charge("maxTextLength", content.text.length);
+        charge("maxContentNodes");
+        const parent = stack.at(-1)?.element;
+        if (events)
+            queued.push({ type: "content", content, parent });
+        if (tree && parent && (content.kind === "text" || content.kind === "cdata"))
+            parent.text += content.text;
+        if (retain)
+            (parent ? parent.content : root ? epilog : prolog).push(content);
+    }
+    parser.on("text", text => { if (text.length)
+        append({ kind: "text", text }); });
+    parser.on("cdata", text => append({ kind: "cdata", text }));
+    parser.on("comment", text => append({ kind: "comment", text }));
+    parser.on("processinginstruction", value => append({ kind: "processing-instruction", target: value.target, text: value.body }));
+    let cr = false, first = true;
+    function write(text) {
+        if (!text)
+            return;
+        if (first) {
+            first = false;
+            if (text.charCodeAt(0) === 0xfeff) {
+                parser.write(text[0]);
+                text = text.slice(1);
+            }
+        }
+        if (cr) {
+            if (text.startsWith("\n"))
+                text = text.slice(1);
+            cr = false;
+        }
+        cr = text.endsWith("\r");
+        text = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+        if (capturing) {
+            prefix += text;
+            if (prefix.length >= 6 && !(prefix.startsWith("<?xml") && " \t\n".includes(prefix[5]))) {
+                prefix = "";
+                capturing = false;
+            }
+        }
+        parser.write(text);
+    }
+    await checkpoint?.(0);
+    for await (const text of source) {
+        if (typeof text !== "string")
+            throw new TypeError("XML producer must yield strings");
+        for (let i = 0; i < text.length; i += 512) {
+            await checkpoint?.(0);
+            write(text.slice(i, i + 512));
+            if (completed.length || queued.length)
+                await drain();
+            await checkpoint?.(Math.min(512, text.length - i));
+        }
+    }
+    await checkpoint?.(0);
+    parser.close();
+    if (completed.length || queued.length)
+        await drain();
+    if (!root)
+        throw new SyntaxError("Invalid XML: incomplete document");
+    return root;
+}

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/package.json

@@ -0,0 +1,25 @@
+{
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "lint": "eslint src && npm run typecheck",
+    "test": "cd ../.. && vitest run packages/xml-ast",
+    "test:unit": "cd ../.. && vitest run packages/xml-ast"
+  }
+}

package/node_modules/toolcraft/node_modules/auth-store/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/toolcraft/node_modules/auth-store/README.md

@@ -25,6 +25,64 @@ const value = await store.get(); // "secret-value"
 await store.delete();
 ```
 
+Use `resolveSecretStoreBackend(options)` to select and validate the backend
+without constructing a store or reading credentials. Pass the returned backend
+explicitly when deferred operations must keep the same environment selection.
+
+Both built-in backends expose `store.withLock(operation, { signal, timeoutMs })`
+for transactions spanning a read, external operation and write. Independent
+instances and processes serialize the same encrypted file or Keychain
+service/account; unrelated identities proceed independently. The default
+acquisition timeout is 30 seconds. Cancellation during acquisition does not
+release the active owner's lock. Each acquisition retains its original signal
+and timeout before path checks wait, including nonenumerable declared options;
+replacing the caller's option handles cannot
+bypass original cancellation or introduce another signal's cancellation. Individual `get`, `set` and `delete` calls do
+not implicitly acquire it.
+
+Locks use private filesystem claim directories, containing PID/random names
+and numeric tickets without credentials. Dead-owner claims are recovered;
+live claims are never stolen because of age. Empty directories remain so an
+arriving contender cannot race directory removal. Keychain lock storage defaults
+to `~/.auth-store/keychain-locks`; `keychainStore.lock` can select another
+directory or filesystem adapter. Injected encrypted-file adapters need
+`readdir` support when using transactions.
+
+## Workers and portable hosts
+
+The `workerd`, `worker`, `browser`, and fallback exports contain no Node built-ins.
+Node retains the desktop API above. Use `auth-store/portable` to select the portable
+API explicitly on any host. It exports `SafeFsSecretStore`, `MigratingSecretStore`,
+`key`, and the portable `SecretStore` contract.
+
+```ts
+import { SafeFsSecretStore } from "auth-store/portable";
+
+const store = new SafeFsSecretStore({
+  fs, // Host-owned @poe-code/safe-fs FileSystem
+  filePath: "/credentials/service.enc",
+  key: encryptionKey, // Host-managed AES-256-GCM CryptoKey; encrypt + decrypt usages
+});
+await store.set("secret-value");
+const value = await store.get();
+await store.delete();
+```
+
+Keep the key in host-managed secret storage; use the same key to read persisted
+credentials across requests. No machine identity, home directory, process, or
+Keychain access is inferred. Web Crypto encrypts UTF-8 bytes with a fresh nonce
+for every write. The AES-GCM document format matches the desktop store when the
+host imports the same derived key. Missing files return `null`; malformed or
+unauthenticated documents throw and remain untouched.
+
+The filesystem must support exclusive creation and atomic rename, and its
+namespace must be controlled by the trusted host. Writes stage a private `0600`
+file and publish it by rename; path checks reject existing symbolic links.
+These checks do not protect against an untrusted actor concurrently changing
+filesystem ancestry. The portable store does not advertise `withLock`: hosts
+must provide transaction coordination across requests or Workers when needed.
+Desktop PID locks and automatic dead-process recovery are not portable.
+
 ## Backends
 
 | `backendEnvVar` value | Platform | Backend        |
@@ -40,8 +98,27 @@ await store.delete();
 - Configurable salt, directory, and file name
 - File permissions: `0600`
 - Random IV per write
+- `fileStore.throwOnInvalidDocument: true` makes malformed or unauthenticated
+  existing documents fail with a safe diagnostic; missing files still return
+  `null`. The default treats invalid documents as absent. Strict reads preserve
+  the existing file until an explicit reset or replacement.
 
 ### macOS Keychain
 
 - Uses the `security` CLI (`add-generic-password`, `find-generic-password`, `delete-generic-password`)
 - Configurable service and account names
+
+## Configuration Options
+
+`createSecretStore()` accepts:
+
+- `backendEnvVar`: optional env var name that selects `file` or `keychain`.
+- `fileStore.salt`: application-specific encryption salt.
+- `fileStore.defaultDirectory`: default credential directory.
+- `fileStore.defaultFileName`: encrypted file name.
+- `keychainStore.service`: macOS Keychain service name.
+- `keychainStore.account`: macOS Keychain account name.
+
+## Environment Variables
+
+This package reads only the caller-selected `backendEnvVar`. It does not define a fixed public env var.

package/node_modules/toolcraft/node_modules/auth-store/dist/create-secret-store.d.ts

@@ -1,2 +1,4 @@
-import type { CreateSecretStoreInput, CreateSecretStoreResult } from "./types.js";
+import type { CreateSecretStoreInput, CreateSecretStoreResult, StoreBackend } from "./types.js";
 export declare function createSecretStore(input: CreateSecretStoreInput): CreateSecretStoreResult;
+/** Select and validate a backend without constructing a store or accessing credentials. */
+export declare function resolveSecretStoreBackend(input: CreateSecretStoreInput): StoreBackend;

package/node_modules/toolcraft/node_modules/auth-store/dist/create-secret-store.js

@@ -17,7 +17,7 @@ const storeFactories = {
     }
 };
 export function createSecretStore(input) {
-    const backend = resolveBackend(input);
+    const backend = resolveSecretStoreBackend(input);
     const platform = input.platform ?? process.platform;
     if (backend === "keychain" && platform !== MACOS_PLATFORM) {
         throw new Error(`Keychain backend is only supported on macOS. Current platform: ${platform}`);
@@ -25,7 +25,8 @@ export function createSecretStore(input) {
     const store = storeFactories[backend](input);
     return { backend, store };
 }
-function resolveBackend(input) {
+/** Select and validate a backend without constructing a store or accessing credentials. */
+export function resolveSecretStoreBackend(input) {
     const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
     const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
     const backend = configuredBackend?.trim();

package/node_modules/toolcraft/node_modules/auth-store/dist/encrypted-file-store.d.ts

@@ -1,9 +1,11 @@
 import type { SecretStore } from "./types.js";
+import { type SecretStoreLockOptions } from "./transaction-lock.js";
 export interface MachineIdentity {
     hostname: string;
     username: string;
 }
 export interface EncryptedFileStoreFileSystem {
+    readdir?(path: string): Promise<string[]>;
     readFile(path: string, encoding: BufferEncoding): Promise<string>;
     writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
         encoding?: BufferEncoding;
@@ -29,6 +31,8 @@ export interface EncryptedFileStoreInput {
     getMachineIdentity?: () => MachineIdentity | Promise<MachineIdentity>;
     getHomeDirectory?: () => string;
     getRandomBytes?: (size: number) => Buffer;
+    /** Fail closed instead of treating malformed or unauthenticated documents as absent. */
+    throwOnInvalidDocument?: boolean;
 }
 export declare class EncryptedFileStore implements SecretStore {
     private readonly fs;
@@ -38,8 +42,10 @@ export declare class EncryptedFileStore implements SecretStore {
     private readonly getMachineIdentity;
     private readonly getRandomBytes;
     private keyPromise;
+    private readonly throwOnInvalidDocument;
     constructor(input: EncryptedFileStoreInput);
     get(): Promise<string | null>;
+    withLock<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
     private assertCredentialPathHasNoSymbolicLinks;

package/node_modules/toolcraft/node_modules/auth-store/dist/encrypted-file-store.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
 import path from "node:path";
 import { hasOwnErrorCode } from "./error-codes.js";
+import { withSecretStoreFileLock } from "./transaction-lock.js";
 const derivedKeyCache = new Map();
 const ENCRYPTION_ALGORITHM = "aes-256-gcm";
 const ENCRYPTION_VERSION = 1;
@@ -18,6 +19,7 @@ export class EncryptedFileStore {
     getMachineIdentity;
     getRandomBytes;
     keyPromise = null;
+    throwOnInvalidDocument;
     constructor(input) {
         this.fs = input.fs ?? fs;
         this.salt = input.salt;
@@ -36,6 +38,7 @@ export class EncryptedFileStore {
         }
         this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
         this.getRandomBytes = input.getRandomBytes ?? randomBytes;
+        this.throwOnInvalidDocument = input.throwOnInvalidDocument ?? false;
     }
     async get() {
         await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
@@ -51,6 +54,8 @@ export class EncryptedFileStore {
         }
         const document = parseEncryptedDocument(rawDocument);
         if (!document) {
+            if (this.throwOnInvalidDocument)
+                throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
             return null;
         }
         const key = await this.getEncryptionKey();
@@ -60,6 +65,8 @@ export class EncryptedFileStore {
             const ciphertext = Buffer.from(document.ciphertext, "base64");
             if (iv.byteLength !== ENCRYPTION_IV_BYTES ||
                 authTag.byteLength !== ENCRYPTION_AUTH_TAG_BYTES) {
+                if (this.throwOnInvalidDocument)
+                    throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
                 return null;
             }
             const decipher = createDecipheriv(ENCRYPTION_ALGORITHM, key, iv);
@@ -68,9 +75,18 @@ export class EncryptedFileStore {
             return plaintext.toString("utf8");
         }
         catch {
+            if (this.throwOnInvalidDocument)
+                throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
             return null;
         }
     }
+    async withLock(operation, options = {}) {
+        options = { ...options, signal: options.signal, timeoutMs: options.timeoutMs };
+        await this.assertCredentialPathHasNoSymbolicLinks(`${this.filePath}.lock`);
+        if (this.fs.readdir === undefined)
+            throw new Error("Secret-store transaction locks require filesystem readdir support");
+        return withSecretStoreFileLock(this.fs, `${this.filePath}.lock`, operation, options);
+    }
     async set(value) {
         await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         const key = await this.getEncryptionKey();

package/node_modules/toolcraft/node_modules/auth-store/dist/index.browser.d.ts

@@ -0,0 +1,4 @@
+export { SafeFsSecretStore } from "./safe-fs-secret-store.js";
+export type { SafeFsSecretStoreInput } from "./safe-fs-secret-store.js";
+export { key, MigratingSecretStore } from "./provider-store.js";
+export type { SecretStore, SecretStoreLockOptions } from "./secret-store.js";

package/node_modules/toolcraft/node_modules/auth-store/dist/index.browser.js

@@ -0,0 +1,2 @@
+export { SafeFsSecretStore } from "./safe-fs-secret-store.js";
+export { key, MigratingSecretStore } from "./provider-store.js";

package/node_modules/toolcraft/node_modules/auth-store/dist/index.d.ts

@@ -1,6 +1,7 @@
-export { createSecretStore } from "./create-secret-store.js";
+export { createSecretStore, resolveSecretStoreBackend } from "./create-secret-store.js";
 export { EncryptedFileStore } from "./encrypted-file-store.js";
 export { KeychainStore } from "./keychain-store.js";
+export type { SecretStoreLockOptions, SecretStoreLockFileSystem } from "./transaction-lock.js";
 export { key, MigratingSecretStore } from "./provider-store.js";
 export type { SecretStore, StoreBackend, CreateSecretStoreInput, CreateSecretStoreResult } from "./types.js";
 export type { MachineIdentity, EncryptedFileStoreInput, EncryptedFileStoreFileSystem } from "./encrypted-file-store.js";

package/node_modules/toolcraft/node_modules/auth-store/dist/index.js

@@ -1,4 +1,4 @@
-export { createSecretStore } from "./create-secret-store.js";
+export { createSecretStore, resolveSecretStoreBackend } from "./create-secret-store.js";
 export { EncryptedFileStore } from "./encrypted-file-store.js";
 export { KeychainStore } from "./keychain-store.js";
 export { key, MigratingSecretStore } from "./provider-store.js";

package/node_modules/toolcraft/node_modules/auth-store/dist/keychain-store.d.ts

@@ -1,4 +1,5 @@
 import type { SecretStore } from "./types.js";
+import { type SecretStoreLockFileSystem, type SecretStoreLockOptions } from "./transaction-lock.js";
 export interface KeychainCommandResult {
     stdout: string;
     stderr: string;
@@ -12,13 +13,20 @@ export interface KeychainStoreInput {
     runCommand?: KeychainCommandRunner;
     service: string;
     account: string;
+    lock?: {
+        fs?: SecretStoreLockFileSystem;
+        directory?: string;
+    };
 }
 export declare class KeychainStore implements SecretStore {
     private readonly runCommand;
     private readonly service;
     private readonly account;
+    private readonly lockFs;
+    private readonly lockDirectory;
     constructor(input: KeychainStoreInput);
     get(): Promise<string | null>;
+    withLock<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
     private executeSecurityCommand;

package/node_modules/toolcraft/node_modules/auth-store/dist/keychain-store.js

@@ -1,14 +1,23 @@
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as nodeFs } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { withSecretStoreFileLock } from "./transaction-lock.js";
 const SECURITY_CLI = "security";
 const KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
 export class KeychainStore {
     runCommand;
     service;
     account;
+    lockFs;
+    lockDirectory;
     constructor(input) {
         this.runCommand = input.runCommand ?? runSecurityCommand;
         this.service = input.service.trim();
         this.account = input.account.trim();
+        this.lockFs = input.lock?.fs ?? nodeFs;
+        this.lockDirectory = input.lock?.directory ?? path.join(homedir(), ".auth-store", "keychain-locks");
         if (this.service.length === 0) {
             throw new Error("Keychain service must not be empty");
         }
@@ -26,6 +35,10 @@ export class KeychainStore {
         }
         throw createSecurityCliFailure("read secret from macOS Keychain", result);
     }
+    async withLock(operation, options = {}) {
+        const identity = createHash("sha256").update(JSON.stringify([this.service, this.account])).digest("hex");
+        return withSecretStoreFileLock(this.lockFs, path.join(this.lockDirectory, identity), operation, options);
+    }
     async set(value) {
         if (value.includes("\n") || value.includes("\r")) {
             throw new Error("Keychain secrets cannot contain line breaks");