@skrr-ai/cli 0.1.115 → 0.1.117

package/dist/lib/task-operations.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskActionCommand = taskActionCommand;
-exports.taskOperationsGuide = taskOperationsGuide;
-exports.taskOperationsGuideLines = taskOperationsGuideLines;
 const shell_quote_1 = require("./shell-quote");
-/** Documentation and display paths only. The server still owns allowedActions. */
+/**
+ * Documentation and display paths only. The server still owns allowedActions.
+ *
+ * `skrr tasks guide`'s command map retired into the tasks guide's `commands`
+ * section (`skrr guide tasks commands`), the one copy every surface reads;
+ * what remains here is the action→command remedies preflight and
+ * actionability render into server-declared allowedActions.
+ */
 function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {}) {
     const task = (0, shell_quote_1.shellQuoteArg)(taskId);
     const target = targetId ? (0, shell_quote_1.shellQuoteArg)(targetId) : '<id>';
@@ -13,7 +18,7 @@ function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {})
         assign_task: `tasks assign ${task} --help`,
         // Managed work already has a current Result. Its server-declared
         // continuation surface distinguishes closing from submitting a new Result.
-        complete_task: context.allowedActions?.some(item => item.action === 'continue_task')
+        complete_task: context.allowedActions?.some((item) => item.action === 'continue_task')
             ? `tasks move ${task} --status done`
             : `tasks complete ${task}`,
         continue_task: `tasks continue ${task} --text "<instruction>" --command-key <key>`,
@@ -31,93 +36,3 @@ function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {})
     };
     return commands[action] ? `${bin} ${commands[action]}` : undefined;
 }
-function taskOperationsGuide(bin = 'skrr') {
-    const command = (usage, purpose) => ({ command: `${bin} ${usage}`, purpose });
-    return {
-        title: 'Task operations',
-        sections: [
-            {
-                title: 'Inspect and plan',
-                commands: [
-                    command('tasks show <task> --json', 'Read the Task, assignment, and dependency IDs.'),
-                    command('tasks actionability <task>', 'Read the canonical next actor, blocker, and allowed actions.'),
-                    command('tasks preflight <task>', 'Read workflow actionability and execution prerequisites together; creates no Run.'),
-                    command('tasks ready --for agent --agent <agent-id>', 'Find workflow-actionable work for an Agent; this does not verify its runtime.'),
-                    command('tasks create-tree --help', 'Create a related Task tree; blockedByTempIds declares dependencies within that tree.'),
-                ],
-            },
-            {
-                title: 'Choose assignment',
-                note: 'Executor intent, assignment, and starting a Run are separate choices. --unassigned clears both assignee kinds and suppresses automatic defaults; it does not start work.',
-                commands: [
-                    command('tasks create --title "Task title" --execution-mode agent --unassigned --dry-run --json', 'Preview Agent-intended work without selecting an Agent or writing a Task.'),
-                    command('tasks assign <task> --unassigned', 'Clear current assignees while retaining executor intent; creates no Run.'),
-                    command('tasks assign <task> --help', 'Choose an eligible Human or Agent explicitly using the native assignment options.'),
-                ],
-            },
-            {
-                title: 'Apply and recover a batch',
-                note: 'Keep the same JSON, scope, and external-key options after an incomplete result. Explicit node externalKey values are preserved; otherwise keys derive from the file and defaults. Changing that input can name new Tasks.',
-                commands: [
-                    command('tasks create-tree --from-json tasks.json --unassigned --readback --json', 'Apply the batch and reread its declared structured fields. This does not start Tasks.'),
-                    command('tasks create-tree --from-json tasks.json --unassigned --resume --readback --json', 'Continue the unchanged file: confirm existing IDs without patching them, create only missing nodes, then read back.'),
-                    command('tasks create-tree --from-json tasks.json --unassigned --verify-spec --json', 'Read-only structured-field comparison. Rich text and unsupported fields are explicitly unchecked; no Expectation assessment or drift repair is performed.'),
-                    command('tasks create-tree --from-json tasks.json --verify --json', 'Read-only existence check by external key. This makes no specification-equality claim.'),
-                ],
-            },
-            {
-                title: 'Name a Project or Goal',
-                note: 'Use exact scoped Project/Goal titles, native refs, or canonical IDs. Duplicate names refuse instead of choosing one. A qualified Project supplies containment; a qualified Goal changes the Goal relationship without moving the Task. Project external keys remain exact and case-sensitive, including keys containing slashes.',
-                commands: [
-                    command('tasks create --title "Task title" --space <space-id> --project "Exact project title" --goal "Exact Goal title" --unassigned --dry-run --json', 'Preview exact names inside the selected Space.'),
-                    command('tasks create --title "Task title" --project "<space-ref>/<project-ref-or-exact-title>" --goal "<space-ref>/<Goal-exact-title>" --unassigned --dry-run --json', 'Preview qualified references; native relationship permissions still apply.'),
-                    command('tasks create --title "Task title" --space <space-id> --project "<project-external-key>" --unassigned --dry-run --json', 'Reuse an existing Project’s native external key without rewriting it.'),
-                ],
-            },
-            {
-                title: 'Edit dependencies',
-                note: 'A waits for B: update A with --add-blocked-by B. These commands change dependencies; inspecting a blocker does not remove it.',
-                commands: [
-                    command('tasks update <task-A> --add-blocked-by <task-B>', 'Make A wait for B.'),
-                    command('tasks update <task-A> --remove-blocked-by <task-B>', 'Remove that dependency when the relationship is no longer intended.'),
-                    command('tasks update <task-B> --add-blocks <task-A>', 'The same relationship, edited from B.'),
-                ],
-            },
-            {
-                title: 'Check execution before starting',
-                note: 'Preflight reads server projections at separate times. It runs no shell command and cannot prove machine directory access, tool availability, or future approval. Starting rechecks current authority.',
-                commands: [
-                    command('tasks start <task> --dry-run --json', 'Read only the server-owned execution preview through the dedicated preview endpoint.'),
-                    command('agents show <agent-id>', 'Inspect the assigned Agent and its configured runtime.'),
-                    command('harnesses show <harness-id> --json', 'Inspect the actual Harness record and reported provider credential readiness, where available.'),
-                    command('harnesses installers --daemon <daemon-id>', 'Ask that daemon about installed coding CLIs and sign-in where it can tell; this is not a shell execution test.'),
-                    command('harnesses ping <harness-id>', 'Explicitly probe a local daemon for reachability; an answer does not prove a provider can run a task.'),
-                    command('tasks start <task>', 'Start a new Run after reviewing the checks. This command executes work.'),
-                ],
-            },
-            {
-                title: 'Follow and finish',
-                commands: [
-                    command('tasks show <task>', 'Inspect current execution and follow the Task link.'),
-                    command('tasks expectations <task>', 'Read what is owed and how it will be checked.'),
-                    command('tasks result submit <task> --help', 'Submit the concrete result and evidence.'),
-                    command('tasks review <task> --help', 'Review another actor’s exact Result.'),
-                    command('tasks complete <task> --help', 'Submit a Result and close out when appropriate.'),
-                    command('instructions guide task-management', 'Read the detailed canonical workflow guide; --offline uses the bundled release copy.'),
-                ],
-            },
-        ],
-    };
-}
-function taskOperationsGuideLines(bin = 'skrr') {
-    const guide = taskOperationsGuide(bin);
-    const lines = [guide.title];
-    for (const section of guide.sections) {
-        lines.push('', section.title);
-        if (section.note)
-            lines.push(section.note);
-        for (const entry of section.commands)
-            lines.push(`  ${entry.command}\n    ${entry.purpose}`);
-    }
-    return lines;
-}

package/dist/lib/task-preflight.js

@@ -22,7 +22,9 @@ function unavailable(error, label) {
             if (typeof body?.code === 'string' && /^[A-Z][A-Z0-9_]{0,100}$/.test(body.code))
                 code = body.code;
         }
-        catch { /* non-JSON server refusal */ }
+        catch {
+            /* non-JSON server refusal */
+        }
     }
     const remedy = status === 401
         ? 'Restore the current CLI sign-in or delegated runtime credential, then repeat this read-only check.'
@@ -32,9 +34,12 @@ function unavailable(error, label) {
                 ? 'Check the Task reference and server support for this diagnostic. No start fallback was attempted.'
                 : 'Read tasks actionability and tasks start --dry-run separately for the native refusal, then repeat preflight after resolving it.';
     return {
-        status: 'unavailable', certainty: 'unknown', code: code || 'TASK_PREFLIGHT_UNAVAILABLE',
+        status: 'unavailable',
+        certainty: 'unknown',
+        code: code || 'TASK_PREFLIGHT_UNAVAILABLE',
         ...(status ? { httpStatus: status } : {}),
-        message: `${label} could not be confirmed${status ? ` (HTTP ${status})` : ''}.`, remedy,
+        message: `${label} could not be confirmed${status ? ` (HTTP ${status})` : ''}.`,
+        remedy,
     };
 }
 function isWorkflow(value, taskId) {
@@ -42,60 +47,92 @@ function isWorkflow(value, taskId) {
         return false;
     const row = value;
     const a = row.actionability;
-    return row.taskId === taskId && Boolean(a &&
-        ['ready', 'running', 'waiting', 'terminal'].includes(a.state) &&
-        ['agent', 'human', 'system', 'external', 'none'].includes(a.nextActor) &&
-        typeof a.reasonCode === 'string' && typeof a.reason === 'string' &&
-        (a.actorRefs === undefined || Array.isArray(a.actorRefs) && a.actorRefs.every(ref => ref && ['user', 'agent'].includes(ref.kind) && typeof ref.id === 'string')) &&
-        Array.isArray(a.allowedActions) && a.allowedActions.every(action => action &&
-        typeof action.action === 'string' && (action.targetId === undefined || typeof action.targetId === 'string')));
+    return (row.taskId === taskId &&
+        Boolean(a &&
+            ['ready', 'running', 'waiting', 'terminal'].includes(a.state) &&
+            ['agent', 'human', 'system', 'external', 'none'].includes(a.nextActor) &&
+            typeof a.reasonCode === 'string' &&
+            typeof a.reason === 'string' &&
+            (a.actorRefs === undefined ||
+                (Array.isArray(a.actorRefs) &&
+                    a.actorRefs.every((ref) => ref && ['user', 'agent'].includes(ref.kind) && typeof ref.id === 'string'))) &&
+            Array.isArray(a.allowedActions) &&
+            a.allowedActions.every((action) => action &&
+                typeof action.action === 'string' &&
+                (action.targetId === undefined || typeof action.targetId === 'string'))));
 }
 function isPreview(value, taskId) {
     if (!(0, task_admission_1.isAdmissionPreview)(value) || value.taskId !== taskId)
         return false;
     const a = value.executionAdmission;
-    return Boolean(typeof a.unattended === 'boolean' && typeof a.approverAvailable === 'boolean' &&
-        (a.constraints === undefined || Array.isArray(a.constraints) && a.constraints.every(c => c &&
-            (c.message === undefined || typeof c.message === 'string') &&
-            (c.requiredAction === undefined || typeof c.requiredAction === 'string'))) &&
-        (a.permission === undefined || a.permission && typeof a.permission === 'object' &&
-            (a.permission.mode == null || typeof a.permission.mode === 'string') &&
-            (a.permission.source === undefined || typeof a.permission.source === 'string')) &&
-        (a.shell === undefined || a.shell && typeof a.shell === 'object' &&
-            (a.shell.state === undefined || typeof a.shell.state === 'string')) &&
-        (a.workingDirectory === undefined || a.workingDirectory &&
-            (a.workingDirectory.path === null || typeof a.workingDirectory.path === 'string') &&
-            typeof a.workingDirectory.source === 'string'));
+    return Boolean(typeof a.unattended === 'boolean' &&
+        typeof a.approverAvailable === 'boolean' &&
+        (a.constraints === undefined ||
+            (Array.isArray(a.constraints) &&
+                a.constraints.every((c) => c &&
+                    (c.message === undefined || typeof c.message === 'string') &&
+                    (c.requiredAction === undefined || typeof c.requiredAction === 'string')))) &&
+        (a.permission === undefined ||
+            (a.permission &&
+                typeof a.permission === 'object' &&
+                (a.permission.mode == null || typeof a.permission.mode === 'string') &&
+                (a.permission.source === undefined || typeof a.permission.source === 'string'))) &&
+        (a.shell === undefined ||
+            (a.shell &&
+                typeof a.shell === 'object' &&
+                (a.shell.state === undefined || typeof a.shell.state === 'string'))) &&
+        (a.workingDirectory === undefined ||
+            (a.workingDirectory &&
+                (a.workingDirectory.path === null || typeof a.workingDirectory.path === 'string') &&
+                typeof a.workingDirectory.source === 'string')));
 }
 /** Compose native reads. This module cannot dispatch execution or infer grants. */
 async function readTaskPreflight(taskId, reads) {
     const [workflowResult, executionResult] = await Promise.allSettled([
-        Promise.resolve().then(reads.workflow), Promise.resolve().then(reads.execution),
+        Promise.resolve().then(reads.workflow),
+        Promise.resolve().then(reads.execution),
     ]);
     const workflow = workflowResult.status === 'fulfilled' && isWorkflow(workflowResult.value, taskId)
         ? { status: 'observed', certainty: 'server_projection', value: workflowResult.value }
-        : unavailable(workflowResult.status === 'rejected' ? workflowResult.reason : { code: 'TASK_ACTIONABILITY_UNSUPPORTED' }, 'Workflow actionability');
+        : unavailable(workflowResult.status === 'rejected'
+            ? workflowResult.reason
+            : { code: 'TASK_ACTIONABILITY_UNSUPPORTED' }, 'Workflow actionability');
     const execution = executionResult.status === 'fulfilled' && isPreview(executionResult.value, taskId)
         ? { status: 'observed', certainty: 'server_projection', value: executionResult.value }
-        : unavailable(executionResult.status === 'rejected' ? executionResult.reason : { code: 'TASK_START_PREVIEW_UNSUPPORTED' }, 'Execution preview');
+        : unavailable(executionResult.status === 'rejected'
+            ? executionResult.reason
+            : { code: 'TASK_START_PREVIEW_UNSUPPORTED' }, 'Execution preview');
     // actionability.revision is the attention revision, not Task.version from
     // start-preview. Equal numbers would not prove the reads shared a snapshot.
     const workflowBlocked = workflow.status === 'observed' &&
-        !workflow.value.actionability.allowedActions.some(action => action.action === 'start_task');
+        !workflow.value.actionability.allowedActions.some((action) => action.action === 'start_task');
     const executionBlocked = execution.status === 'observed' && execution.value.executionAdmission.state === 'blocked';
-    const summary = workflowBlocked || executionBlocked ? 'blocked'
-        : workflow.status === 'unavailable' || execution.status === 'unavailable' ||
-            execution.value.executionAdmission.state !== 'ready' ? 'unknown'
+    const summary = workflowBlocked || executionBlocked
+        ? 'blocked'
+        : workflow.status === 'unavailable' ||
+            execution.status === 'unavailable' ||
+            execution.value.executionAdmission.state !== 'ready'
+            ? 'unknown'
             : 'eligible_to_attempt';
-    return { taskId, summary, workflow, execution, consistency: 'independent_observations', limits: [...LIMITS] };
+    return {
+        taskId,
+        summary,
+        workflow,
+        execution,
+        consistency: 'independent_observations',
+        limits: [...LIMITS],
+    };
 }
 function taskPreflightLines(report, bin = 'skrr') {
-    const lines = [`Task preflight: ${report.taskId}`, `Start eligibility: ${report.summary.replaceAll('_', ' ')} (current server projections)`];
+    const lines = [
+        `Task preflight: ${report.taskId}`,
+        `Start eligibility: ${report.summary.replaceAll('_', ' ')} (current server projections)`,
+    ];
     if (report.workflow.status === 'observed') {
         const a = report.workflow.value.actionability;
         lines.push('', `Workflow: ${a.state} (server projection)`, `Next actor: ${a.nextActor}`, `Why: ${a.reason} [${a.reasonCode}]`);
         if (a.actorRefs?.length)
-            lines.push(`Eligible actors: ${a.actorRefs.map(ref => `${ref.kind}:${ref.id}`).join(', ')}`);
+            lines.push(`Eligible actors: ${a.actorRefs.map((ref) => `${ref.kind}:${ref.id}`).join(', ')}`);
         for (const action of a.allowedActions) {
             const command = (0, task_operations_1.taskActionCommand)(action.action, report.taskId, action.targetId, bin, {
                 allowedActions: a.allowedActions,
@@ -116,6 +153,6 @@ function taskPreflightLines(report, bin = 'skrr') {
     }
     else
         lines.push('', `Execution: unknown. ${report.execution.message} [${report.execution.code}]`, `Next step: ${report.execution.remedy}`);
-    lines.push('', ...report.limits, `More operations: ${bin} tasks guide`);
+    lines.push('', ...report.limits, `More operations: ${bin} guide tasks commands`);
     return lines;
 }

package/dist/lib/task-resolver.d.ts

@@ -22,6 +22,14 @@ export declare function resolveTaskIdentity({ positionalId, flagTask, jsonBody,
     /** Injectable so commands and tests can control the local git fallback. */
     gitTaskReference?: () => string | null;
 }): TaskIdentity;
+/**
+ * The same resolution `resolveTaskIdentity` performs, without the throw.
+ * Read-only surfaces that REPORT task context (`skrr context`) need the
+ * identical answer an id-less task command would act on — runtime binding
+ * first, then the `oversky/task/<REF>` git branch — but "no task anywhere"
+ * is a fact to print, not an error to fail on.
+ */
+export declare function tryResolveTaskIdentity(options?: Parameters<typeof resolveTaskIdentity>[0]): TaskIdentity | null;
 /**
  * Normalize a `resolveTaskIdentity` throw into the `{ code, message, suggestion }`
  * shape `failWithCliError` wants.

package/dist/lib/task-resolver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskResolutionError = void 0;
 exports.resolveTaskIdentity = resolveTaskIdentity;
+exports.tryResolveTaskIdentity = tryResolveTaskIdentity;
 exports.taskResolutionFailure = taskResolutionFailure;
 exports.stripTaskIdentityFields = stripTaskIdentityFields;
 const runtime_context_1 = require("./runtime-context");
@@ -85,6 +86,23 @@ function resolveTaskIdentity({ positionalId, flagTask, jsonBody, jsonKeys = ['ta
         },
     });
 }
+/**
+ * The same resolution `resolveTaskIdentity` performs, without the throw.
+ * Read-only surfaces that REPORT task context (`skrr context`) need the
+ * identical answer an id-less task command would act on — runtime binding
+ * first, then the `oversky/task/<REF>` git branch — but "no task anywhere"
+ * is a fact to print, not an error to fail on.
+ */
+function tryResolveTaskIdentity(options = {}) {
+    try {
+        return resolveTaskIdentity(options);
+    }
+    catch (err) {
+        if (err instanceof TaskResolutionError)
+            return null;
+        throw err;
+    }
+}
 /**
  * Normalize a `resolveTaskIdentity` throw into the `{ code, message, suggestion }`
  * shape `failWithCliError` wants.

package/dist/lib/usage-discovery.d.ts

@@ -33,6 +33,10 @@ export declare const USAGE_OVERVIEW_TOKEN_BUDGET = 240;
  * `skrr widgets check`, and the app runs in the same frame. Its own overview line took the first read from 240 to 241
  * tokens, and this file's rule for that is to fold into a domain that already has the concept, not to raise the bound.
  * `skrr usage apps` still resolves, to the `widgets` pages, which name it in `Includes:`.
+ * `instruction-blocks` (version-pinned instruction blocks for cloud Agents) is the same concept as
+ * `instructions` (version-pinned blocks for local CLAUDE.md / AGENTS.md), aimed at another target. The overview
+ * read 245 once `skrr guide` joined it, and `guide` stays a line of its own because it is where every operation
+ * guide is read.
  */
 export declare const USAGE_DOMAIN_FOLDS: Readonly<Record<string, string>>;
 export declare const USAGE_DOMAIN_TOKEN_BUDGET = 500;

package/dist/lib/usage-discovery.js

@@ -44,10 +44,15 @@ exports.USAGE_OVERVIEW_TOKEN_BUDGET = 240;
  * `skrr widgets check`, and the app runs in the same frame. Its own overview line took the first read from 240 to 241
  * tokens, and this file's rule for that is to fold into a domain that already has the concept, not to raise the bound.
  * `skrr usage apps` still resolves, to the `widgets` pages, which name it in `Includes:`.
+ * `instruction-blocks` (version-pinned instruction blocks for cloud Agents) is the same concept as
+ * `instructions` (version-pinned blocks for local CLAUDE.md / AGENTS.md), aimed at another target. The overview
+ * read 245 once `skrr guide` joined it, and `guide` stays a line of its own because it is where every operation
+ * guide is read.
  */
 exports.USAGE_DOMAIN_FOLDS = {
     proposals: 'inbox',
     apps: 'widgets',
+    'instruction-blocks': 'instructions',
 };
 exports.USAGE_DOMAIN_TOKEN_BUDGET = 500;
 const GENERIC_FLAGS = new Set(['bare', 'help', 'json', 'token', 'workspace']);

package/dist/lib/voice-call-intent.js

@@ -74,9 +74,11 @@ function readVoiceCallSessionContext(env = process.env) {
     };
 }
 function generatedVoiceCallIdempotencyKey({ context, reason, conversationId, expiresInSeconds, }) {
+    if (!context.requestId)
+        return `voice-call:${crypto.randomUUID()}`;
     const input = [
         context.sessionId,
-        context.requestId || 'no-request-id',
+        context.requestId,
         context.agentId,
         reason,
         conversationId || '',

package/dist/lib/write-target.d.ts

@@ -25,5 +25,5 @@ export declare function matchesExpectedTarget(target: WriteTarget, expected: str
 export declare function firstUnmetExpectation(target: WriteTarget, expected: readonly string[] | undefined): string | undefined;
 /** The assertion flag, declared once so every bulk writer spells it the same way. */
 export declare const expectTargetFlag: {
-    'expect-target': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'expect-target': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/aead.js

@@ -1,65 +1,81 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AEAD_TAG_LEN = exports.AEAD_NONCE_LEN = exports.AEAD_KEY_LEN = void 0;
-exports.aeadSeal = aeadSeal;
-exports.aeadOpen = aeadOpen;
-/**
- * aead.ts — shared AES-256-GCM primitive for auth-core envelope formats.
- *
- * CredentialEnvelope (L12 at-rest) uses AES-256-GCM. This module owns the
- * bare cipher operation; framing, versioning, and serialization live in its
- * envelope module.
- */
-const node_crypto_1 = __importDefault(require("node:crypto"));
-/** AEAD algorithm. */
-const ALG = 'aes-256-gcm';
-/** Key length in bytes (256 bits). */
-exports.AEAD_KEY_LEN = 32;
-/** Nonce length in bytes (96-bit GCM standard). */
-exports.AEAD_NONCE_LEN = 12;
-/** GCM authentication tag length in bytes (128 bits). */
-exports.AEAD_TAG_LEN = 16;
-/**
- * Seal `plaintext` under `key` with optional `aad`. A fresh 96-bit nonce is
- * generated per call — callers must never reuse nonces for the same key.
- *
- * Throws if `key` is not exactly 32 bytes.
- */
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aead_exports = {};
+__export(aead_exports, {
+  AEAD_KEY_LEN: () => AEAD_KEY_LEN,
+  AEAD_NONCE_LEN: () => AEAD_NONCE_LEN,
+  AEAD_TAG_LEN: () => AEAD_TAG_LEN,
+  aeadOpen: () => aeadOpen,
+  aeadSeal: () => aeadSeal
+});
+module.exports = __toCommonJS(aead_exports);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+const ALG = "aes-256-gcm";
+const AEAD_KEY_LEN = 32;
+const AEAD_NONCE_LEN = 12;
+const AEAD_TAG_LEN = 16;
 function aeadSeal(plaintext, key, aad) {
-    if (!Buffer.isBuffer(key) || key.length !== exports.AEAD_KEY_LEN) {
-        throw new TypeError(`aeadSeal: key must be a ${exports.AEAD_KEY_LEN}-byte Buffer`);
-    }
-    const nonce = node_crypto_1.default.randomBytes(exports.AEAD_NONCE_LEN);
-    const cipher = node_crypto_1.default.createCipheriv(ALG, key, nonce);
-    if (aad && aad.length > 0)
-        cipher.setAAD(aad);
-    const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return { nonce, ct, tag };
+  if (!Buffer.isBuffer(key) || key.length !== AEAD_KEY_LEN) {
+    throw new TypeError(`aeadSeal: key must be a ${AEAD_KEY_LEN}-byte Buffer`);
+  }
+  const nonce = import_node_crypto.default.randomBytes(AEAD_NONCE_LEN);
+  const cipher = import_node_crypto.default.createCipheriv(ALG, key, nonce);
+  if (aad && aad.length > 0)
+    cipher.setAAD(aad);
+  const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return { nonce, ct, tag };
 }
-/**
- * Open a sealed AEAD blob. Throws on any authentication failure (wrong key,
- * wrong AAD, truncated ciphertext). Never silently returns garbage.
- */
 function aeadOpen(sealed, key, aad) {
-    if (!Buffer.isBuffer(key) || key.length !== exports.AEAD_KEY_LEN) {
-        throw new TypeError(`aeadOpen: key must be a ${exports.AEAD_KEY_LEN}-byte Buffer`);
-    }
-    if (!Buffer.isBuffer(sealed.nonce) || sealed.nonce.length !== exports.AEAD_NONCE_LEN) {
-        throw new Error('aeadOpen: invalid nonce length');
-    }
-    if (!Buffer.isBuffer(sealed.tag) || sealed.tag.length !== exports.AEAD_TAG_LEN) {
-        throw new Error('aeadOpen: invalid auth tag length');
-    }
-    if (!Buffer.isBuffer(sealed.ct)) {
-        throw new Error('aeadOpen: ciphertext must be a Buffer');
-    }
-    const decipher = node_crypto_1.default.createDecipheriv(ALG, key, sealed.nonce);
-    if (aad && aad.length > 0)
-        decipher.setAAD(aad);
-    decipher.setAuthTag(sealed.tag);
-    return Buffer.concat([decipher.update(sealed.ct), decipher.final()]);
+  if (!Buffer.isBuffer(key) || key.length !== AEAD_KEY_LEN) {
+    throw new TypeError(`aeadOpen: key must be a ${AEAD_KEY_LEN}-byte Buffer`);
+  }
+  if (!Buffer.isBuffer(sealed.nonce) || sealed.nonce.length !== AEAD_NONCE_LEN) {
+    throw new Error("aeadOpen: invalid nonce length");
+  }
+  if (!Buffer.isBuffer(sealed.tag) || sealed.tag.length !== AEAD_TAG_LEN) {
+    throw new Error("aeadOpen: invalid auth tag length");
+  }
+  if (!Buffer.isBuffer(sealed.ct)) {
+    throw new Error("aeadOpen: ciphertext must be a Buffer");
+  }
+  const decipher = import_node_crypto.default.createDecipheriv(ALG, key, sealed.nonce);
+  if (aad && aad.length > 0)
+    decipher.setAAD(aad);
+  decipher.setAuthTag(sealed.tag);
+  return Buffer.concat([decipher.update(sealed.ct), decipher.final()]);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AEAD_KEY_LEN,
+  AEAD_NONCE_LEN,
+  AEAD_TAG_LEN,
+  aeadOpen,
+  aeadSeal
+});