@ory/argus 0.9.1 → 0.11.0

package/assets/skills/auth-setup/SKILL.md

@@ -233,7 +233,9 @@ Create the following page structure:
 - `app/auth/registration/page.tsx` — `<Registration flow={flow} />`
 - `app/auth/recovery/page.tsx` — `<Recovery flow={flow} />`
 - `app/auth/verification/page.tsx` — `<Verification flow={flow} />`
-- `app/auth/settings/page.tsx` — `<Settings flow={flow} />`
+- `app/auth/settings/page.tsx` — `<Settings flow={flow} />`, wrapped in
+  `<SessionProvider>` from `@ory/elements-react/client` (Settings is the only
+  flow that needs it — see {{REF_LOGIN_FLOW}})
 
 Each page initializes its flow with `getLoginFlow`, `getRegistrationFlow`,
 etc. from `@ory/nextjs/app`, then hands the flow to the matching

package/assets/skills/login-flow/SKILL.md

@@ -264,6 +264,7 @@ Create `app/auth/settings/page.tsx`:
 
 ```typescript
 import { Settings } from "@ory/elements-react/theme"
+import { SessionProvider } from "@ory/elements-react/client"
 import { getSettingsFlow, OryPageLayout } from "@ory/nextjs/app"
 
 export default async function SettingsPage(props: {
@@ -278,16 +279,26 @@ export default async function SettingsPage(props: {
 
   return (
     <OryPageLayout>
-      <Settings flow={flow} />
+      <SessionProvider>
+        <Settings flow={flow} />
+      </SessionProvider>
     </OryPageLayout>
   )
 }
 ```
 
+Unlike the other flows, **`<Settings>` must be wrapped in `<SessionProvider>`**
+from `@ory/elements-react/client`. Settings renders session-dependent controls
+(connected social accounts, unlinking, logout of other sessions) that read from
+the session context; the pre-auth pages (login, registration, recovery,
+verification) have no session yet and do not need the provider.
+
 ### Settings — React SPA
 
 Initialize with `createBrowserSettingsFlow` and render
-`<Settings flow={flow} />` from `@ory/elements-react/theme`. The
+`<Settings flow={flow} />` from `@ory/elements-react/theme`, wrapped in
+`<SessionProvider>` from `@ory/elements-react/client` (the same requirement
+as the App Router page above — Settings reads session-dependent state). The
 component handles password changes, profile traits, MFA enrollment,
 and connected social providers.
 
@@ -385,6 +396,71 @@ For larger design changes, the Ory Elements primitives package exposes
 the underlying card, button, and input components — use those before
 falling back to custom node rendering.
 
+## Enable MFA and passkeys
+
+These are **project-side** capabilities: once enabled on the Ory project, the
+`<Login>`, `<Registration>`, and `<Settings>` components render the second-factor
+and passkey UI automatically — **no page code changes**. Configure them with the
+Ory CLI against your project (`ory list projects` for the id), the same idiom as
+{{REF_SOCIAL_LOGIN}}. Against the local stack, apply the equivalent keys to the
+local Kratos config instead ({{REF_LOCAL_DEV}}).
+
+### Passkeys
+
+```bash
+ory patch identity-config <project-id> \
+  --add '/selfservice/methods/passkey/enabled=true' \
+  --add '/selfservice/methods/passkey/config/rp/display_name="My App"' \
+  --add '/selfservice/methods/passkey/config/rp/id="your-domain.com"' \
+  --add '/selfservice/methods/passkey/config/rp/origins=["https://your-domain.com"]'
+```
+
+- `rp.id` is the **domain only** — no scheme, no port (`example.com`, not
+  `https://example.com:3000`).
+- `rp.origins` must list the **exact scheme+host+port** the browser uses.
+- For local dev, WebAuthn treats `localhost` as a secure origin: set
+  `rp.id="localhost"` and `rp.origins=["http://localhost:3000"]` (match your app
+  URL). Passkeys registered against `localhost` won't work on the deployed domain
+  and vice-versa.
+
+### MFA methods
+
+Enable the second factors you want. Backup codes (`lookup_secret`) should always
+be enabled alongside any other method so a user who loses their device can
+recover.
+
+```bash
+# TOTP (authenticator app)
+ory patch identity-config <project-id> \
+  --add '/selfservice/methods/totp/enabled=true' \
+  --add '/selfservice/methods/totp/config/issuer="My App"'
+
+# Backup codes
+ory patch identity-config <project-id> \
+  --add '/selfservice/methods/lookup_secret/enabled=true'
+
+# Email code as a second factor
+ory patch identity-config <project-id> \
+  --add '/selfservice/methods/code/mfa_enabled=true'
+```
+
+### Require the second factor (do not skip)
+
+Enabling a method only lets users *enroll* — it does not *require* the second
+factor. Without this step MFA is opt-in and unenforced. Set the required
+assurance level to the highest the identity has available:
+
+```bash
+ory patch identity-config <project-id> \
+  --add '/selfservice/flows/settings/required_aal="highest_available"' \
+  --add '/session/whoami/required_aal="highest_available"'
+```
+
+With `highest_available`, `toSession()` / `getServerSession()` return an
+incomplete session (AAL1) until the user clears the second factor, and Elements
+prompts for it on the next `<Login>`. Your route protection should treat an
+AAL1 session on an MFA-enrolled user as unauthenticated.
+
 ## Test the flow
 
 Don't stop at "the page renders." Run these in order — each one isolates a
@@ -415,6 +491,43 @@ If a submit fails with a CSRF error, the SDK URL is cross-site (trap #1). If a
 redirect 404s, a route doesn't match the project config (trap #2). Neither is a
 plugin bug — see the **App bug vs. plugin bug** triage in {{REF_AUTH_SETUP}}.
 
+### Writing E2E tests (Playwright)
+
+Automating these flows has three gotchas that cause flaky or wrong-for-the-wrong-
+reason failures. Get them right up front:
+
+1. **Match URLs by pattern, never literally.** Ory appends `?flow=<uuid>` on
+   every flow redirect, so an exact-string wait never matches.
+
+   ```typescript
+   await page.waitForURL(/\/auth\/login\?flow=/)   // regex
+   await page.waitForURL("**/dashboard**")          // glob — also matches query params
+   // wrong: await page.waitForURL("http://localhost:3000/auth/login")
+   ```
+
+2. **Use strong, dissimilar credentials.** Kratos rejects passwords that are too
+   similar to the identifier or that appear in a breach database — a weak fixture
+   password fails validation, not the flow you meant to test.
+
+   ```typescript
+   const email = `test-${Date.now()}-${Math.random().toString(36).slice(2)}@example.com`
+   const password = "Str0ngP@ssword!123"   // fixed, strong, not in any breach list
+   ```
+
+3. **Assert on Ory Elements' own testids, not form-level selectors.** Validation
+   messages render inside the auth card, keyed by Kratos UI message id (the
+   `4xxxxxx` range is validation errors), not on the flow wrapper.
+
+   ```typescript
+   page.locator('[data-testid^="ui/message/4"]')  // any validation error
+   page.locator('[data-testid="login-auth-card"]').getByText(/credentials|invalid/i)
+   // wrong: page.locator('[data-testid="login-flow"]').getByText(...) — errors aren't here
+   ```
+
+These selectors track the installed `@ory/elements-react` version; if a testid
+assertion breaks after an Elements upgrade, inspect the rendered DOM before
+assuming a flow bug.
+
 ## Fallback: rendering UI nodes by hand
 
 Use this path **only** when Ory Elements cannot run in the target
@@ -437,8 +550,9 @@ Ory flow API changes manually.
 - Add social login providers: use {{REF_SOCIAL_LOGIN}}.
   Elements renders the buttons automatically once providers are
   configured server-side.
-- Add multi-factor authentication via Ory project settings — the
-  `<Login>` and `<Settings>` components handle the second-factor UI.
+- Add multi-factor authentication and passkeys — see **Enable MFA and
+  passkeys** above. Once the project is configured, the `<Login>` and
+  `<Settings>` components render the second-factor and passkey UI automatically.
 - Customize the identity schema for additional profile fields. Elements
   reads the schema from the flow and renders new fields automatically.
 - Set up webhooks for registration events.

package/dist/adapters.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared adapter primitives for Agent SDK integrations (and harness plugins).
+ *
+ * These extract the session-start sequencing and the `tool.invoke` / `tool.block` /
+ * `tool.complete` span boilerplate that each integration would otherwise re-implement, so
+ * an SDK binding is a thin translation between the SDK's hook signature and these calls.
+ * They are the TypeScript twin of `ory_argus.adapters` in the Python core.
+ *
+ *   - {@link sessionStart} — run the user + agent auth gates and write the user→agent
+ *     delegation tuple; returns whether the session may proceed.
+ *   - {@link gate} — resolve the subject, run {@link gateToolCall}, record the spans, and
+ *     return a normalized {@link GateResult}.
+ *   - {@link complete} — record the `tool.complete` span.
+ *   - {@link registerSubagent} — resolve a sub-agent identity + agent→subagent tuple.
+ *   - {@link wrapTool} — wrap a plain `execute(args)` with gate+complete, for SDKs whose
+ *     only veto point is the tool boundary (Vercel AI SDK, etc.).
+ *
+ * Every primitive is best-effort and fail-open.
+ */
+import type { OryAgentClient } from "./client.js";
+import { ensureAgentIdentity, ensureSubAgentIdentity } from "./agent-auth.js";
+import { ensureUserAuthenticated } from "./user-login.js";
+import { type PermissionDecision } from "./permissions.js";
+export declare function resolveNamespace(): string;
+export interface SessionStartResult {
+    proceed: boolean;
+    userMode: string;
+    userReason: string;
+    agentKind: string;
+}
+export interface SessionStartOptions {
+    harness: string;
+    allowBlock?: boolean;
+    projectUrl?: string;
+    binName?: string;
+    /** Injectable gates (tests). */
+    userLogin?: typeof ensureUserAuthenticated;
+    agentGate?: typeof ensureAgentIdentity;
+}
+/**
+ * Run both auth gates and write the user→agent delegation tuple. `allowBlock` is advisory
+ * for in-process SDK integrations (the agent can't be prevented from constructing), but the
+ * user gate still runs, refreshes tokens, and records the `user.auth` span.
+ */
+export declare function sessionStart(client: OryAgentClient, opts: SessionStartOptions): Promise<SessionStartResult>;
+export interface RegisterSubagentOptions {
+    harness: string;
+    subAgentType: string;
+    projectUrl?: string;
+    subAgentGate?: typeof ensureSubAgentIdentity;
+}
+export declare function registerSubagent(client: OryAgentClient, opts: RegisterSubagentOptions): Promise<void>;
+export interface GateResult {
+    /** False only when the tool was hard-denied in enforce mode. */
+    proceed: boolean;
+    /** True only for that deny (and only when `canBlock`). */
+    blocked: boolean;
+    /** Discriminator: allow / observe / deny / fail_open / interactive / audit_only. */
+    kind: string;
+    decision: ToolGateOutcomeLike;
+    subject: string;
+    namespace: string;
+    denialMessage?: string;
+}
+type ToolGateOutcomeLike = {
+    kind: "audit_only";
+    spanAttributes: Record<string, unknown>;
+} | {
+    kind: "interactive";
+    spanAttributes: Record<string, unknown>;
+} | PermissionDecision;
+export interface GateOptions {
+    harness: string;
+    toolName: string;
+    toolArgs?: unknown;
+    subjectFallback?: string;
+    /** Whether the calling integration can actually stop the tool. */
+    canBlock?: boolean;
+    extraSpanAttributes?: Record<string, unknown>;
+}
+/**
+ * Authorize a tool call, record the spans, and return a normalized {@link GateResult}.
+ * Records `tool.invoke` on allow/observe and `tool.block` on deny/observe — identical span
+ * semantics to the harness plugins.
+ */
+export declare function gate(client: OryAgentClient, opts: GateOptions): Promise<GateResult>;
+export declare function complete(client: OryAgentClient, opts: {
+    toolName: string;
+    output?: unknown;
+    extraSpanAttributes?: Record<string, unknown>;
+    status?: "ok" | "error";
+}): void;
+export interface WrapToolOptions {
+    harness: string;
+    toolName: string;
+    canBlock?: boolean;
+}
+/**
+ * Wrap a plain `execute(args)` callable with gate + complete. On a hard deny it throws
+ * {@link OryDenialError} (the veto mechanism for tool-boundary SDKs like Vercel AI SDK);
+ * otherwise the tool runs and `tool.complete` is recorded.
+ */
+export declare function wrapTool<A, R>(client: OryAgentClient, opts: WrapToolOptions, execute: (args: A) => R | Promise<R>): (args: A) => Promise<R>;
+export {};

package/dist/adapters.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Shared adapter primitives for Agent SDK integrations (and harness plugins).
+ *
+ * These extract the session-start sequencing and the `tool.invoke` / `tool.block` /
+ * `tool.complete` span boilerplate that each integration would otherwise re-implement, so
+ * an SDK binding is a thin translation between the SDK's hook signature and these calls.
+ * They are the TypeScript twin of `ory_argus.adapters` in the Python core.
+ *
+ *   - {@link sessionStart} — run the user + agent auth gates and write the user→agent
+ *     delegation tuple; returns whether the session may proceed.
+ *   - {@link gate} — resolve the subject, run {@link gateToolCall}, record the spans, and
+ *     return a normalized {@link GateResult}.
+ *   - {@link complete} — record the `tool.complete` span.
+ *   - {@link registerSubagent} — resolve a sub-agent identity + agent→subagent tuple.
+ *   - {@link wrapTool} — wrap a plain `execute(args)` with gate+complete, for SDKs whose
+ *     only veto point is the tool boundary (Vercel AI SDK, etc.).
+ *
+ * Every primitive is best-effort and fail-open.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNamespace = resolveNamespace;
+exports.sessionStart = sessionStart;
+exports.registerSubagent = registerSubagent;
+exports.gate = gate;
+exports.complete = complete;
+exports.wrapTool = wrapTool;
+const config_js_1 = require("./config.js");
+const agent_auth_js_1 = require("./agent-auth.js");
+const user_login_js_1 = require("./user-login.js");
+const permissions_js_1 = require("./permissions.js");
+const subject_js_1 = require("./subject.js");
+const denial_js_1 = require("./denial.js");
+function resolveNamespace() {
+    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
+}
+/**
+ * Run both auth gates and write the user→agent delegation tuple. `allowBlock` is advisory
+ * for in-process SDK integrations (the agent can't be prevented from constructing), but the
+ * user gate still runs, refreshes tokens, and records the `user.auth` span.
+ */
+async function sessionStart(client, opts) {
+    const projectUrl = opts.projectUrl ?? (0, config_js_1.resolveConfig)().projectUrl;
+    const userLogin = opts.userLogin ?? user_login_js_1.ensureUserAuthenticated;
+    const agentGate = opts.agentGate ?? agent_auth_js_1.ensureAgentIdentity;
+    const decision = await userLogin(client, {
+        binName: opts.binName ?? `ory-${opts.harness}`,
+        harness: opts.harness,
+        allowBlock: opts.allowBlock ?? false,
+    });
+    const creds = await agentGate(client, {
+        projectUrl,
+        harness: opts.harness,
+    });
+    await recordUserDelegatesAgent(client);
+    return {
+        proceed: decision.proceed,
+        userMode: decision.mode,
+        userReason: decision.reason,
+        agentKind: creds.kind,
+    };
+}
+async function recordUserDelegatesAgent(client) {
+    const user = client.userPrincipal.subject;
+    const agent = client.agentPrincipal.subject;
+    if (!user || !agent)
+        return;
+    try {
+        await client.createRelationship({
+            namespace: resolveNamespace(),
+            object: `agent:${agent}`,
+            relation: "delegate",
+            subjectId: `user:${user}`,
+        }, { spanAttributes: { delegation: "user-to-agent" } });
+    }
+    catch (err) {
+        client.logger.warn("delegation.user_to_agent.failed", {
+            message: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+async function registerSubagent(client, opts) {
+    const projectUrl = opts.projectUrl ?? (0, config_js_1.resolveConfig)().projectUrl;
+    const subAgentGate = opts.subAgentGate ?? agent_auth_js_1.ensureSubAgentIdentity;
+    let identity;
+    try {
+        identity = await subAgentGate(client, {
+            subAgentType: opts.subAgentType,
+            projectUrl,
+            harness: opts.harness,
+        });
+    }
+    catch (err) {
+        client.logger.warn("subagent.identity.failed", {
+            subAgentType: opts.subAgentType,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return;
+    }
+    if (identity.kind !== "dynamic" || !identity.subject)
+        return;
+    const agent = client.agentPrincipal.subject;
+    if (!agent)
+        return;
+    try {
+        await client.createRelationship({
+            namespace: resolveNamespace(),
+            object: `subagent:${identity.subject}`,
+            relation: "delegate",
+            subjectId: `agent:${agent}`,
+        }, { spanAttributes: { delegation: "agent-to-subagent", subAgentType: opts.subAgentType } });
+    }
+    catch (err) {
+        client.logger.warn("delegation.agent_to_subagent.failed", {
+            subAgentType: opts.subAgentType,
+            message: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+/**
+ * Authorize a tool call, record the spans, and return a normalized {@link GateResult}.
+ * Records `tool.invoke` on allow/observe and `tool.block` on deny/observe — identical span
+ * semantics to the harness plugins.
+ */
+async function gate(client, opts) {
+    const namespace = resolveNamespace();
+    const subjectRef = (0, subject_js_1.resolveUserSubject)(client, opts.subjectFallback);
+    const label = (0, subject_js_1.subjectLabel)(subjectRef);
+    const canBlock = opts.canBlock ?? true;
+    const spanAttrs = { toolName: opts.toolName, ...(opts.extraSpanAttributes ?? {}) };
+    const check = { namespace, object: opts.toolName, relation: "use", ...subjectRef };
+    // Audit-only kill switch: Ory is disabled entirely — no permission check.
+    // Record only the audit `tool.invoke` span (same span semantics as the
+    // harness plugins' audit-only short-circuit) and pass the tool through.
+    const resolved = (0, config_js_1.resolveConfig)();
+    if (resolved.auditOnly) {
+        client.tracer.record("tool.invoke", "ok", { attributes: spanAttrs });
+        const decision = {
+            kind: "allow",
+            result: { allowed: true, checkedAt: new Date().toISOString(), check },
+            mode: resolved.permissionMode,
+            spanAttributes: { permissionMode: resolved.permissionMode },
+        };
+        return { proceed: true, blocked: false, kind: "allow", decision, subject: label, namespace };
+    }
+    const outcome = await (0, permissions_js_1.gateToolCall)(client, {
+        harness: opts.harness,
+        toolName: opts.toolName,
+        check,
+        spanAttributes: spanAttrs,
+    });
+    if (outcome.kind === "audit_only") {
+        // Kill switch: Ory is disabled. Audit the invocation, skip the check.
+        client.tracer.record("tool.invoke", "ok", {
+            attributes: { ...spanAttrs, auditOnly: true },
+        });
+        return { proceed: true, blocked: false, kind: "audit_only", decision: outcome, subject: label, namespace };
+    }
+    if (outcome.kind === "interactive") {
+        return { proceed: true, blocked: false, kind: "interactive", decision: outcome, subject: label, namespace };
+    }
+    const decisionAttrs = outcome.spanAttributes;
+    if (outcome.kind === "fail_open") {
+        client.logger.warn("permission.fail_open", { tool: opts.toolName, code: outcome.error.code });
+        return { proceed: true, blocked: false, kind: "fail_open", decision: outcome, subject: label, namespace };
+    }
+    if (outcome.kind === "allow") {
+        client.tracer.record("tool.invoke", "ok", {
+            attributes: { ...spanAttrs, ...decisionAttrs, allowed: true },
+        });
+        return { proceed: true, blocked: false, kind: "allow", decision: outcome, subject: label, namespace };
+    }
+    if (outcome.kind === "observe") {
+        client.tracer.record("tool.block", "denied", {
+            attributes: { ...spanAttrs, ...decisionAttrs, allowed: false, ...(0, denial_js_1.alertAttributes)(false) },
+        });
+        client.tracer.record("tool.invoke", "ok", {
+            attributes: { ...spanAttrs, ...decisionAttrs, allowed: false, observed: true },
+        });
+        return { proceed: true, blocked: false, kind: "observe", decision: outcome, subject: label, namespace };
+    }
+    // deny
+    client.tracer.record("tool.block", "denied", {
+        attributes: { ...spanAttrs, ...decisionAttrs, allowed: false, ...(0, denial_js_1.alertAttributes)(canBlock) },
+    });
+    const denialMessage = (0, denial_js_1.formatDenialMessage)({ tool: opts.toolName, subjectId: label, namespace });
+    client.logger.warn("tool.denied", { tool: opts.toolName, subjectId: label });
+    return { proceed: false, blocked: canBlock, kind: "deny", decision: outcome, subject: label, namespace, denialMessage };
+}
+function complete(client, opts) {
+    const attributes = { toolName: opts.toolName, ...(opts.extraSpanAttributes ?? {}) };
+    if (opts.output !== undefined)
+        attributes.hasOutput = true;
+    client.tracer.record("tool.complete", opts.status ?? "ok", { attributes });
+}
+/**
+ * Wrap a plain `execute(args)` callable with gate + complete. On a hard deny it throws
+ * {@link OryDenialError} (the veto mechanism for tool-boundary SDKs like Vercel AI SDK);
+ * otherwise the tool runs and `tool.complete` is recorded.
+ */
+function wrapTool(client, opts, execute) {
+    return async (args) => {
+        const result = await gate(client, {
+            harness: opts.harness,
+            toolName: opts.toolName,
+            toolArgs: args,
+            canBlock: opts.canBlock ?? true,
+        });
+        if (result.blocked) {
+            throw new denial_js_1.OryDenialError({ tool: opts.toolName, subjectId: result.subject, namespace: result.namespace });
+        }
+        const output = await execute(args);
+        complete(client, { toolName: opts.toolName, output });
+        return output;
+    };
+}

package/dist/agent-auth.js

@@ -384,6 +384,20 @@ async function fetchClientCredentialsToken(args) {
  * the agent identity was available for the session.
  */
 async function ensureAgentIdentity(client, options = {}) {
+    // Audit-only kill switch: Ory is disabled entirely — skip credential
+    // resolution (no DCR, no token grant) and record the no-op, shaped like
+    // the user gate's audit_only result.
+    if ((0, config_js_1.resolveConfig)().auditOnly) {
+        const creds = {
+            kind: "none",
+            reason: "Configured for audit-only mode; agent identity resolution is a no-op",
+            warnings: [],
+        };
+        client.tracer.record("agent.auth", "skipped", {
+            attributes: { kind: creds.kind, reason: creds.reason, auditOnly: true },
+        });
+        return creds;
+    }
     const resolveFn = options.resolveFn ?? resolveAgentCredentials;
     let creds;
     try {
@@ -437,6 +451,25 @@ async function ensureAgentIdentity(client, options = {}) {
  * resolution.
  */
 async function ensureSubAgentIdentity(client, options) {
+    // Audit-only kill switch: same no-op as ensureAgentIdentity — no
+    // sub-agent DCR while Ory is disabled entirely.
+    if ((0, config_js_1.resolveConfig)().auditOnly) {
+        const identity = {
+            kind: "none",
+            subAgentType: options.subAgentType,
+            reason: "Configured for audit-only mode; sub-agent identity resolution is a no-op",
+            warnings: [],
+        };
+        client.tracer.record("agent.auth", "skipped", {
+            attributes: {
+                kind: "subagent_none",
+                subAgentType: identity.subAgentType,
+                reason: identity.reason,
+                auditOnly: true,
+            },
+        });
+        return identity;
+    }
     const env = options.env ?? process.env;
     const registerFn = options.registerAgentClientFn ?? registerAgentClient;
     const loadFn = options.loadFn ?? loadSubAgentDynamicCredentials;

package/dist/config.js

@@ -290,15 +290,47 @@ function acquireLock() {
                 throw new Error(`Timed out waiting for config lock at ${lockPath}. ` +
                     "Another process may be holding it; remove the file if you are sure no other process is running.");
             }
-            sleepSync(LOCK_POLL_MS);
+            if (!sleepSync(LOCK_POLL_MS)) {
+                // The runtime can't block synchronously (no SharedArrayBuffer /
+                // Atomics.wait — e.g. Cloudflare Workers). Rather than hot-spin
+                // until the deadline, proceed without the lock: the write itself
+                // stays atomic via write-temp + rename.
+                return { fd: null };
+            }
         }
     }
 }
-const SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * Lazily initialized buffer for `Atomics.wait`-based synchronous sleep.
+ * `undefined` = not yet probed; `null` = unavailable on this runtime.
+ * Never touched at module scope: constructing a SharedArrayBuffer eagerly
+ * would make merely importing this module throw on runtimes without it
+ * (e.g. Cloudflare Workers).
+ */
+let sleepBuf;
+/** Sleep synchronously. Returns false when the runtime can't sleep. */
 function sleepSync(ms) {
-    Atomics.wait(SLEEP_BUF, 0, 0, ms);
+    if (sleepBuf === undefined) {
+        try {
+            sleepBuf =
+                typeof SharedArrayBuffer === "function" &&
+                    typeof Atomics !== "undefined" &&
+                    typeof Atomics.wait === "function"
+                    ? new Int32Array(new SharedArrayBuffer(4))
+                    : null;
+        }
+        catch {
+            sleepBuf = null;
+        }
+    }
+    if (sleepBuf === null)
+        return false;
+    Atomics.wait(sleepBuf, 0, 0, ms);
+    return true;
 }
 function releaseLock(lock) {
+    if (lock.fd === null)
+        return; // lock-less fallback: nothing to release
     try {
         fs.closeSync(lock.fd);
     }