cursedbelt 2.8.0 → 3.0.0

package/dist/server/guard/kdfWorker.js

@@ -1,302 +0,0 @@
-/**
- * The off-thread KDF (05 §B6) — a long-lived worker that owns every byte of key
- * material it produces.
- *
- * ## The problem
- *
- * argon2id at the platform parameters is ~150–250 ms of *pure CPU*. The KDF seam
- * is synchronous by design (see `Argon2idDeriver` — the async bindings return
- * un-zeroizable PHC strings), so that time is spent on the event loop with
- * nothing else able to run. There is no race and no correctness bug; there is a
- * hard throughput ceiling. A saas node handling a burst of logins serializes
- * them AND stalls every unrelated request for the duration, so one tenant's
- * login storm is every other tenant's latency spike.
- *
- * ## The design, and the one thing that makes it worth building
- *
- * The naive off-thread KDF derives in a worker and posts the KEY BACK. That
- * moves the CPU but weakens custody: the key crosses a structured-clone boundary
- * (a copy the sender cannot zeroize, because clone semantics leave the original
- * behind and the receiver adopts a second allocation), and it lands in a host
- * that must remember to destroy it.
- *
- * **Nothing here posts a key.** The worker runs the SHIPPED
- * `sealPasswordVerifier` / `verifyPasswordEnvelope` — the same functions, the
- * same envelope format, the same one KDF — so the derived key is born, used and
- * zeroized entirely inside the worker thread. What crosses back is a boolean or
- * the sealed *ciphertext*. The password crosses inward, because it arrives from
- * the request and must; the worker zeroizes its copy on every path, and the host
- * zeroizes its own.
- *
- * That is why this is a worker for the whole VERIFY rather than a worker for the
- * derivation: relocating the derivation alone would have traded a throughput
- * problem for a custody problem.
- *
- * ## Long-lived, never per-call
- *
- * Thread startup plus module load (a native argon2 binding!) is tens of
- * milliseconds, and a spawn-per-login design lets a login storm fork unbounded
- * OS threads — which is the same denial of service the ceiling above, only
- * worse. One thread, multiplexed by request id. This is the mistake
- * `createMarshalWorkerClient` documents in `core/wire/marshalWorker.ts`; it is
- * repeated here deliberately in the same shape so both read alike.
- */
-import { AppError } from '../errors';
-import { createInProcessPasswordVerifier, sealPasswordVerifier, verifyPasswordEnvelope, } from './passwordVerifier';
-import { registerNodeRsArgon2id } from './argon2Binding';
-/** Raised when the worker thread dies, fails to start, or is disposed mid-flight. */
-export const GUARD_KDF_WORKER_FAILED = 'GUARD_KDF_WORKER_FAILED';
-/** Raised when the worker does not answer within the configured budget. */
-export const GUARD_KDF_WORKER_TIMEOUT = 'GUARD_KDF_WORKER_TIMEOUT';
-/**
- * Default per-request ceiling. Generous relative to a ~250 ms derivation on
- * purpose: this is a liveness backstop for a wedged thread, not a latency SLO,
- * and a tight budget here would turn a loaded machine into a login outage.
- */
-export const KDF_WORKER_DEFAULT_TIMEOUT_MS = 15_000;
-const nodeWorkerScope = async () => {
-    const { parentPort } = await import('node:worker_threads');
-    if (parentPort === null)
-        throw new Error('serveKdfWorker() was called outside a worker thread.');
-    return {
-        postMessage: (data) => parentPort.postMessage(data),
-        onMessage: (handler) => parentPort.on('message', handler),
-    };
-};
-/**
- * Run the KDF worker's message loop. A worker entry module is this call and
- * nothing else (see `kdfWorkerEntry.ts`).
- *
- * `register` is injectable so the spec can drive the loop with a cheap fake
- * binding — registering the real native argon2 in a test that only checks
- * message plumbing would pay 250 ms per case to prove nothing about the
- * plumbing. The DEFAULT is the real binding, because a worker that silently ran
- * a fake KDF would be a catastrophe rather than a bug.
- */
-export async function serveKdfWorker(options = {}) {
-    const scope = options.scope ?? (await nodeWorkerScope());
-    // Registration happens ONCE, at worker start, before any request is served —
-    // not lazily per request, or the first login of every thread pays a native
-    // module load inside its own timeout budget.
-    await (options.register ?? registerNodeRsArgon2id)();
-    scope.onMessage((data) => {
-        const request = data;
-        if (typeof request?.id !== 'number')
-            return;
-        // The password arrives as a structured-clone copy owned by THIS thread.
-        // Re-wrap anything that is not already a Uint8Array rather than trusting the
-        // wire type — a plain `{0:..,1:..}` would silently derive from the wrong
-        // bytes instead of failing — but keep the inbound view too, because it is a
-        // second plaintext copy this thread is responsible for.
-        const inbound = request.password;
-        const password = inbound instanceof Uint8Array ? inbound : new Uint8Array(inbound);
-        try {
-            const value = request.kind === 'seal'
-                ? sealPasswordVerifier(request.userId, password)
-                : verifyPasswordEnvelope(request.userId, request.envelopeJson, password);
-            scope.postMessage({ id: request.id, ok: true, value });
-        }
-        catch (error) {
-            // Only the CODE and message cross back. An error `context` in this module
-            // can hold envelope fields, so the envelope itself never leaves.
-            scope.postMessage({
-                id: request.id,
-                ok: false,
-                code: (error instanceof AppError ? error.code : undefined) ?? GUARD_KDF_WORKER_FAILED,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            // Both `sealPasswordVerifier` and `verifyPasswordEnvelope` consume (and so
-            // zeroize) the buffer they are handed — but they are the far side of a
-            // contract, and a throw BEFORE they are reached (a malformed envelope, an
-            // unregistered deriver) leaves a plaintext password in worker RAM. Clearing
-            // again is idempotent and costs a memset.
-            //
-            // EVERY view, not just the one that was used: when the wire type is wrong
-            // the re-wrap above makes a second allocation, and zeroizing only the copy
-            // we derived from would leave the structured clone this thread was handed
-            // sitting in memory for the life of the worker.
-            password.fill(0);
-            if (inbound !== password && inbound instanceof Uint8Array)
-                inbound.fill(0);
-        }
-    });
-}
-function spawnHostWorker(entry) {
-    // Callers await `settled` rather than seeing the construction race. It is
-    // RESOLVED, never rejected, on every exit path including a failed spawn: a
-    // rejection here would surface as an unhandled rejection on a request that the
-    // error handler below is already failing properly.
-    let realPost = null;
-    let markSettled = () => undefined;
-    const settled = new Promise((resolve) => {
-        markSettled = resolve;
-    });
-    let terminated = false;
-    const messageHandlers = [];
-    const errorHandlers = [];
-    let terminateReal = null;
-    void (async () => {
-        try {
-            const { Worker } = await import('node:worker_threads');
-            if (terminated)
-                return;
-            const worker = new Worker(entry);
-            worker.on('message', (data) => {
-                for (const handler of messageHandlers)
-                    handler(data);
-            });
-            worker.on('error', (error) => {
-                for (const handler of errorHandlers)
-                    handler(error);
-            });
-            // ANY exit is a failure: this worker is long-lived by design, so it should
-            // outlive every request. A cleanly-exited thread that went unnoticed would
-            // leave each in-flight login waiting out its full timeout, and every later
-            // one posting into a dead thread to do the same.
-            worker.on('exit', (code) => {
-                const how = code === 0 ? 'exited cleanly while still in use' : `exited with code ${code}`;
-                for (const handler of errorHandlers)
-                    handler(new Error(`KDF worker ${how}`));
-            });
-            realPost = (data) => worker.postMessage(data);
-            terminateReal = () => void worker.terminate();
-        }
-        catch (error) {
-            for (const handler of errorHandlers)
-                handler(error);
-        }
-        finally {
-            markSettled();
-        }
-    })();
-    return {
-        async post(data) {
-            if (realPost === null)
-                await settled;
-            // Still null ⇒ the spawn failed or we were disposed mid-construction. The
-            // error handler has already failed (or will fail) the request; dropping
-            // the message is correct, and the caller may now zeroize.
-            realPost?.(data);
-        },
-        onMessage: (handler) => messageHandlers.push(handler),
-        onError: (handler) => errorHandlers.push(handler),
-        terminate: () => {
-            terminated = true;
-            markSettled();
-            terminateReal?.();
-        },
-    };
-}
-/**
- * A {@link PasswordVerifierPort} backed by one long-lived worker thread.
- *
- * Hand it to `createAccountService({ passwords })` on a host that expects login
- * concurrency. Local single-user hosts should NOT — they would pay a thread and
- * a native module load to serialize a workload that was never contended.
- */
-export function createKdfWorkerPasswordVerifier(options) {
-    const timeoutMs = options.timeoutMs ?? KDF_WORKER_DEFAULT_TIMEOUT_MS;
-    const worker = (options.spawn ?? spawnHostWorker)(options.entry);
-    const pending = new Map();
-    let nextId = 1;
-    let disposed = false;
-    const settle = (id, apply) => {
-        const entry = pending.get(id);
-        if (!entry)
-            return; // already timed out — a late reply is discarded
-        pending.delete(id);
-        clearTimeout(entry.timer);
-        apply(entry);
-    };
-    const failure = (message, code, status) => new AppError(message, { code, status, category: 'security', context: { worker: String(options.entry) } });
-    worker.onMessage((data) => {
-        const response = data;
-        if (typeof response?.id !== 'number')
-            return;
-        settle(response.id, (p) => {
-            if (response.ok) {
-                p.resolve(response.value);
-                return;
-            }
-            // Preserve the worker's own code: `SECRET_ENVELOPE_*` failures are a
-            // corrupt row, not a dead thread, and a caller distinguishing them must
-            // still be able to.
-            p.reject(failure(response.message, response.code, 500));
-        });
-    });
-    // A dead worker takes every request in flight with it — failing them now beats
-    // each one waiting out its own timeout.
-    worker.onError((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        for (const id of [...pending.keys()])
-            settle(id, (p) => p.reject(failure(`KDF worker failed: ${message}`, GUARD_KDF_WORKER_FAILED, 500)));
-    });
-    /**
-     * Post the request, zeroize the host's copy of the password as soon as the
-     * thread has it, then await the verdict.
-     *
-     * The zeroize placement is the point. The worker holds a structured-clone
-     * copy, so the host's buffer is dead weight the instant the post lands —
-     * and the await that follows lasts the whole ~250 ms derivation, which is
-     * exactly the window in which a heap snapshot, a core dump or a crash reporter
-     * would capture a plaintext password. Clearing it before the await instead of
-     * in a `finally` after it removes that window entirely.
-     */
-    const send = async (build, password) => {
-        if (disposed)
-            throw failure('The KDF worker has been disposed.', GUARD_KDF_WORKER_FAILED, 500);
-        const id = nextId++;
-        const answer = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                pending.delete(id);
-                reject(failure(`The KDF worker did not answer within ${timeoutMs}ms.`, GUARD_KDF_WORKER_TIMEOUT, 504));
-            }, timeoutMs);
-            pending.set(id, { resolve, reject, timer });
-        });
-        try {
-            await worker.post(build(id));
-        }
-        finally {
-            password.fill(0);
-        }
-        return await answer;
-    };
-    return {
-        async seal(userId, password) {
-            const value = await send((id) => ({ id, kind: 'seal', userId, password }), password);
-            if (typeof value !== 'string')
-                throw failure('The KDF worker returned a non-string envelope for seal().', GUARD_KDF_WORKER_FAILED, 500);
-            return value;
-        },
-        async verify(userId, envelopeJson, password) {
-            const value = await send((id) => ({ id, kind: 'verify', userId, envelopeJson, password }), password);
-            if (typeof value !== 'boolean')
-                throw failure('The KDF worker returned a non-boolean verdict for verify().', GUARD_KDF_WORKER_FAILED, 500);
-            return value;
-        },
-        async dispose() {
-            disposed = true;
-            for (const id of [...pending.keys()])
-                settle(id, (p) => p.reject(failure('The KDF worker was disposed while a request was in flight.', GUARD_KDF_WORKER_FAILED, 503)));
-            worker.terminate();
-        },
-    };
-}
-/**
- * The URL of the entry module {@link createKdfWorkerPasswordVerifier} spawns.
- *
- * Resolved relative to THIS module rather than hard-coded by the host, so an app
- * never has to know where inside the package the entry lives:
- *
- *   createKdfWorkerPasswordVerifier({ entry: kdfWorkerEntryUrl() })
- *
- * Under the `bun` export condition this resolves to the TypeScript source, which
- * is what every first-party consumer runs (see the monorepo's zero-build-lag
- * contract). A non-Bun host consuming built `dist/` names its own built entry.
- */
-export const kdfWorkerEntryUrl = () => new URL('./kdfWorkerEntry.ts', import.meta.url);
-/** Re-exported so a host wiring the guard tier needs one import. */
-export { createInProcessPasswordVerifier };
-//# sourceMappingURL=kdfWorker.js.map

package/dist/server/guard/kdfWorker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kdfWorker.js","sourceRoot":"","sources":["../../../src/server/guard/kdfWorker.ts"],"names":[],"mappings":"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"}

package/dist/server/guard/kdfWorkerEntry.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=kdfWorkerEntry.d.ts.map

package/dist/server/guard/kdfWorkerEntry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kdfWorkerEntry.d.ts","sourceRoot":"","sources":["../../../src/server/guard/kdfWorkerEntry.ts"],"names":[],"mappings":""}

package/dist/server/guard/kdfWorkerEntry.js

@@ -1,16 +0,0 @@
-/**
- * The SHIPPED KDF worker entry (05 §B6).
- *
- * Unlike a marshalling worker — where every marshaller declares its own entry
- * because every marshaller has its own schema — there is exactly ONE password
- * KDF in the platform (Law #7), so there is exactly one entry and the framework
- * ships it. A host does not write this file; it points
- * `createKdfWorkerPasswordVerifier({ entry: kdfWorkerEntryUrl() })` at it.
- *
- * The whole module is one call on purpose: everything a worker entry does that
- * is not "start the loop" is code running on a thread with a live argon2id
- * binding and a plaintext password in scope.
- */
-import { serveKdfWorker } from './kdfWorker';
-await serveKdfWorker();
-//# sourceMappingURL=kdfWorkerEntry.js.map

package/dist/server/guard/kdfWorkerEntry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kdfWorkerEntry.js","sourceRoot":"","sources":["../../../src/server/guard/kdfWorkerEntry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,cAAc,EAAE,CAAC"}

package/dist/server/guard/passwordVerifier.d.ts

@@ -1,66 +0,0 @@
-import { type Argon2idDeriver } from 'cwip/guard';
-/**
- * Seal a password verifier for `userId`, returning the serialized `SecretEnvelope`
- * to store in `users.pw_envelope`. **Consumes `password`** (zeroized before return).
- *
- * A fresh per-user KDF salt is minted for each call, so two users with the same
- * password produce different envelopes and re-deriving one never helps the other.
- */
-export declare function sealPasswordVerifier(userId: string, password: Uint8Array, deriver?: Argon2idDeriver): string;
-/**
- * Check `password` against the stored `envelopeJson` for `userId`. **Consumes
- * `password`** (zeroized before return). Returns `true` iff the password is
- * correct; `false` for a wrong password (GCM authentication failure). A malformed
- * stored envelope is corruption, not a wrong password, and re-throws.
- *
- * The comparison is constant-time in the sensitive part: argon2id derivation
- * dominates the timing, and GCM tag verification plus the final `timingSafeEqual`
- * are constant-time, so a right and a wrong password of equal length are
- * indistinguishable by timing.
- */
-export declare function verifyPasswordEnvelope(userId: string, envelopeJson: string, password: Uint8Array, deriver?: Argon2idDeriver): boolean;
-/**
- * Where password derivation RUNS (05 §B6).
- *
- * The two functions above are synchronous on purpose — the KDF seam is, and for
- * the reason documented on `Argon2idDeriver`: every async argon2id binding hands
- * back a promise AND a base64/PHC *string*, which is key material that cannot be
- * zeroized. The cost is that one derivation is ~150–250 ms of pure CPU on the
- * event loop, so concurrent logins SERIALIZE and stall every unrelated request
- * on the process for that window. A single-user local app never notices; a saas
- * node taking a burst of logins does, and so does every tenant sharing it.
- *
- * This port is the seam that lets a host move that burn off the request thread
- * WITHOUT introducing a second KDF, a second envelope format, or an async
- * deriver. Both implementations call the exact same `sealPasswordVerifier` /
- * `verifyPasswordEnvelope` above; they differ only in which thread runs them.
- *
- *   local / default   {@link createInProcessPasswordVerifier} — direct calls,
- *                     byte-for-byte the behavior that shipped before this port
- *                     existed.
- *   saas / opt-in     `createKdfWorkerPasswordVerifier` (`./kdfWorker`) — a
- *                     long-lived worker thread. **No key material crosses the
- *                     thread boundary in either direction**: the password goes
- *                     in, the derived key is born, used and zeroized inside the
- *                     worker, and only a boolean (or the sealed ciphertext)
- *                     comes back.
- *
- * Both entry points CONSUME `password` — ownership transfers on the call, and
- * the buffer is zeroized on every path including a throw.
- */
-export interface PasswordVerifierPort {
-    /** Seal a verifier for `userId`, returning the serialized envelope. Consumes `password`. */
-    seal(userId: string, password: Uint8Array): Promise<string>;
-    /** `true` iff `password` matches `envelopeJson`. Consumes `password`. */
-    verify(userId: string, envelopeJson: string, password: Uint8Array): Promise<boolean>;
-    /** Release any thread/handle the implementation owns. In-process: a no-op. */
-    dispose?(): Promise<void>;
-}
-/**
- * The default port: derive on the calling thread, exactly as every caller did
- * before the port existed. Nothing about the crypto changes — this is the same
- * two functions behind a promise, so a host that never opts into the worker
- * path pays no async penalty beyond one already-resolved microtask.
- */
-export declare function createInProcessPasswordVerifier(deriver?: Argon2idDeriver): PasswordVerifierPort;
-//# sourceMappingURL=passwordVerifier.d.ts.map

package/dist/server/guard/passwordVerifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"passwordVerifier.d.ts","sourceRoot":"","sources":["../../../src/server/guard/passwordVerifier.ts"],"names":[],"mappings":"AAgCA,OAAO,EACL,KAAK,eAAe,EAMrB,MAAM,YAAY,CAAC;AAgBpB;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,CAU5G;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CA2BT;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,oBAAoB;IACnC,4FAA4F;IAC5F,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5D,yEAAyE;IACzE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrF,8EAA8E;IAC9E,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,oBAAoB,CAS/F"}

package/dist/server/guard/passwordVerifier.js

@@ -1,123 +0,0 @@
-/**
- * Password verifiers over the ONE KDF (02 §2, Law #7).
- *
- * A login password check needs a *verifier* — something stored per user that a
- * presented password can be checked against — WITHOUT introducing a second hash
- * function or a second at-rest secret format. The platform already ships exactly
- * one of each: the argon2id seam (`cwip/.../guard/kdf.ts`) and the
- * `SecretEnvelope` (`cwip/.../guard/secretEnvelope.ts`). This module builds the
- * verifier out of those, adding nothing.
- *
- * The trick: a verifier is a `SecretEnvelope` that seals a FIXED known plaintext
- * under a key argon2id-derived from the user's password. To check a password,
- * re-derive the one-shot key from the presented password and try to open the
- * envelope — GCM's authentication tag IS the password check. A wrong password
- * derives a wrong key and GCM refuses (`SECRET_ENVELOPE_AUTH_FAILED`), which we
- * translate to `false`; a right password opens and the recovered plaintext
- * matches the known constant. No password hash is ever stored, compared, or even
- * computed outside the KDF, and the envelope is the same `pw_envelope` string the
- * registry `users.pw_envelope` column already types.
- *
- * Two properties that are not incidental:
- *
- *   - **The verifier is bound to its user.** The envelope AAD is `cc-pw:<userId>`,
- *     so a `pw_envelope` lifted out of user A's row into user B's fails GCM
- *     authentication rather than letting B log in with A's password (the same
- *     swap defense `SecretEnvelope` gives every secret).
- *   - **Byte custody (01 §3.4).** Both entry points CONSUME the password buffer:
- *     the underlying manager zeroizes it the moment the KDF is done with it, on
- *     every path including a thrown KDF. Callers hand over ownership and must not
- *     touch the buffer afterwards.
- */
-import { timingSafeEqual } from 'node:crypto';
-import { createSecretEnvelopeManager, mintEnvelopeSalt, parseSecretEnvelope, serializeSecretEnvelope, zeroize, } from 'cwip/guard';
-import { isAppError } from '../errors';
-/**
- * The reserved AAD app namespace for password verifiers. `SecretEnvelope` forbids
- * a ':' in the appId (it separates the AAD fields), so this is a plain token; the
- * userId rides the AAD `key` half.
- */
-const PW_APP = 'cc-pw';
-/** The fixed plaintext every verifier seals — its recovery on open is the success signal. */
-const VERIFIER_PLAINTEXT = new TextEncoder().encode('cc-guard-pw-verifier-v1');
-/** Bind an envelope to one user: AAD becomes `cc-pw:<userId>`. */
-const refFor = (userId) => ({ appId: PW_APP, key: userId });
-/**
- * Seal a password verifier for `userId`, returning the serialized `SecretEnvelope`
- * to store in `users.pw_envelope`. **Consumes `password`** (zeroized before return).
- *
- * A fresh per-user KDF salt is minted for each call, so two users with the same
- * password produce different envelopes and re-deriving one never helps the other.
- */
-export function sealPasswordVerifier(userId, password, deriver) {
-    const manager = createSecretEnvelopeManager({ salt: mintEnvelopeSalt(), deriver });
-    try {
-        // unlock derives the master key from (password, salt) and zeroizes `password`
-        // in its own finally — including if the KDF throws.
-        manager.unlock(password);
-        return serializeSecretEnvelope(manager.seal(refFor(userId), VERIFIER_PLAINTEXT));
-    }
-    finally {
-        manager.lock();
-    }
-}
-/**
- * Check `password` against the stored `envelopeJson` for `userId`. **Consumes
- * `password`** (zeroized before return). Returns `true` iff the password is
- * correct; `false` for a wrong password (GCM authentication failure). A malformed
- * stored envelope is corruption, not a wrong password, and re-throws.
- *
- * The comparison is constant-time in the sensitive part: argon2id derivation
- * dominates the timing, and GCM tag verification plus the final `timingSafeEqual`
- * are constant-time, so a right and a wrong password of equal length are
- * indistinguishable by timing.
- */
-export function verifyPasswordEnvelope(userId, envelopeJson, password, deriver) {
-    let envelope;
-    try {
-        envelope = parseSecretEnvelope(envelopeJson);
-    }
-    catch (error) {
-        // A stored envelope that will not parse is a tampered/corrupt row — never
-        // silently treat it as "wrong password". Zeroize the buffer we were handed
-        // before propagating (the manager never got a chance to).
-        zeroize(password);
-        throw error;
-    }
-    const manager = createSecretEnvelopeManager({ salt: mintEnvelopeSalt(), deriver });
-    let opened = null;
-    try {
-        // openWithPassphrase re-derives a one-shot key from the envelope's own salt +
-        // the presented password, opens, and zeroizes `password` on every path.
-        opened = manager.openWithPassphrase(envelope, refFor(userId), password);
-        return opened.byteLength === VERIFIER_PLAINTEXT.byteLength && timingSafeEqual(opened, VERIFIER_PLAINTEXT);
-    }
-    catch (error) {
-        // GCM's rejection is the wrong-password verdict — the ONLY error we swallow.
-        if (isAppError(error) && error.code === 'SECRET_ENVELOPE_AUTH_FAILED')
-            return false;
-        throw error;
-    }
-    finally {
-        if (opened)
-            zeroize(opened);
-        manager.lock();
-    }
-}
-/**
- * The default port: derive on the calling thread, exactly as every caller did
- * before the port existed. Nothing about the crypto changes — this is the same
- * two functions behind a promise, so a host that never opts into the worker
- * path pays no async penalty beyond one already-resolved microtask.
- */
-export function createInProcessPasswordVerifier(deriver) {
-    return {
-        async seal(userId, password) {
-            return sealPasswordVerifier(userId, password, deriver);
-        },
-        async verify(userId, envelopeJson, password) {
-            return verifyPasswordEnvelope(userId, envelopeJson, password, deriver);
-        },
-    };
-}
-//# sourceMappingURL=passwordVerifier.js.map

package/dist/server/guard/passwordVerifier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"passwordVerifier.js","sourceRoot":"","sources":["../../../src/server/guard/passwordVerifier.ts"],"names":[],"mappings":"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"}