@onesi/genesis 0.2.4 → 0.2.6

package/dist/hives-cells.d.ts

@@ -84,6 +84,16 @@ export interface HivesPresignedUrl {
     required_headers?: Record<string, string>;
 }
 export declare function hivesObjectKey(key: string): string;
+/** A replay of the same Idempotency-Key: Hives answers with the original settled receipt and no result. */
+export interface HivesStorageWriteReplay {
+    replayed: true;
+    key: string;
+    bucket_id: string;
+    operation_id: string;
+    state: 'settled';
+    storage_operation_id: string | null;
+    funding_source: string | null;
+}
 export declare function hivesCells(client: GenesisClient): {
     list(project: string, query?: {
         page?: number;
@@ -114,18 +124,18 @@ export declare function hivesCells(client: GenesisClient): {
         }, options?: HivesResourceOptions): Promise<HivesObjectList>;
         put(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: HivesFundedWriteOptions & {
             content_type?: string;
-        }): Promise<HivesObjectAcknowledgement>;
+        }): Promise<HivesObjectAcknowledgement | HivesStorageWriteReplay>;
         remove: (project: string, id: string, key: string, options?: HivesResourceOptions) => Promise<void>;
         download: (project: string, id: string, key: string, options?: HivesResourceOptions) => Promise<Response>;
         /** Existing flat-key path compatibility; nested keys use canonical collection methods above. */
         putFlat(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: HivesFundedWriteOptions & {
             content_type?: string;
-        }): Promise<HivesObjectAcknowledgement>;
+        }): Promise<HivesObjectAcknowledgement | HivesStorageWriteReplay>;
         removeFlat: (project: string, id: string, key: string, options?: HivesResourceOptions) => Promise<void>;
         /** The flat key "download" on its own static route, which shadows /objects/{key} for that key. */
         putDownload(project: string, id: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: HivesFundedWriteOptions & {
             content_type?: string;
-        }): Promise<HivesObjectAcknowledgement>;
+        }): Promise<HivesObjectAcknowledgement | HivesStorageWriteReplay>;
         removeDownload: (project: string, id: string, options?: HivesResourceOptions) => Promise<void>;
     };
     presign(project: string, id: string, body: HivesPresign, options?: HivesResourceOptions): Promise<HivesPresignedUrl>;

package/dist/hives-cells.js

@@ -1,3 +1,4 @@
+import { GenesisError } from './errors.js';
 import { HIVES_OBJECT_BYTES, hivesFundedWriteHeaders, hivesResourceCall, hivesResourceId, hivesObjectBody, hivesContentType, resourceError } from './hives-resources-transport.js';
 export function hivesObjectKey(key) {
     const bytes = new TextEncoder().encode(key);
@@ -59,11 +60,28 @@ function object(value, id) {
     hivesObjectKey(value.key);
     return Object.fromEntries(['key', 'bucket_id', 'size_bytes', 'etag', 'last_modified', 'generation', 'content_type', 'metadata', 'metadata_scope'].map(k => [k, value[k]]));
 }
-function acknowledgement(answer, key, id, size) {
+const OPERATION_ID = /^fop_[0-9a-f]{32}$/, STATE = /^[a-z][a-z_]{0,31}$/;
+function acknowledgement(answer, key, id, size, operation) {
     // A funded write answers with its settled storage operation receipt; the acknowledgement is its result.
     const receipt = answer;
-    if (receipt && receipt.object !== undefined && (receipt.object !== 'storage_write_operation' || receipt.state !== 'settled'))
-        throw resourceError(0);
+    if (receipt && receipt.object !== undefined) {
+        if (receipt.object !== 'storage_write_operation')
+            throw resourceError(0);
+        const operation_id = typeof receipt.operation_id === 'string' && OPERATION_ID.test(receipt.operation_id) ? receipt.operation_id : undefined;
+        if (receipt.state !== 'settled') {
+            const state = typeof receipt.state === 'string' && STATE.test(receipt.state) ? receipt.state : 'unknown';
+            throw new GenesisError({ status: 0, type: 'invalid_request', code: 'HIVES_STORAGE_WRITE_NOT_SETTLED', operationId: operation, body: { operation_id: operation_id ?? null, state },
+                message: ['denied', 'released'].includes(state)
+                    ? `Hives did not perform this storage write (state ${state}${operation_id ? `, operation_id ${operation_id}` : ''}). This outcome is final: a replay of the same Idempotency-Key returns it again. No automatic retry was made.`
+                    : `Hives has not settled this storage write (state ${state}${operation_id ? `, operation_id ${operation_id}` : ''}). Replay the same Idempotency-Key to read its outcome; no automatic retry was made.` });
+        }
+        if (receipt.result === undefined) {
+            if (!operation_id)
+                throw resourceError(0);
+            const text = (v) => typeof v === 'string' && v.length <= 256 ? v : null;
+            return { replayed: true, key, bucket_id: id, operation_id, state: 'settled', storage_operation_id: text(receipt.storage_operation_id), funding_source: text(receipt.funding_source) };
+        }
+    }
     const value = (receipt?.object === undefined ? answer : receipt.result);
     if (!value || value.bucket_id !== id || value.key !== key || value.size_bytes !== size || !Number.isSafeInteger(value.size_bytes) || value.size_bytes < 0 || typeof value.etag !== 'string' || typeof value.generation !== 'string' || value.content_type !== null && typeof value.content_type !== 'string')
         throw resourceError(0);
@@ -120,7 +138,7 @@ export function hivesCells(client) {
             async put(project, id, key, bytes, options = {}) {
                 const body = await hivesObjectBody(bytes);
                 const content_type = hivesContentType(options.content_type);
-                return acknowledgement(await write('hives_upload_object_by_key', { ...ids(project, id), key_base64url: hivesObjectKey(key), body, content_type }, options), key, id, body.byteLength);
+                return acknowledgement(await write('hives_upload_object_by_key', { ...ids(project, id), key_base64url: hivesObjectKey(key), body, content_type }, options), key, id, body.byteLength, 'hives_upload_object_by_key');
             },
             remove: (project, id, key, options) => call('hives_delete_object_by_key', { ...ids(project, id), key_base64url: hivesObjectKey(key) }, options, 'empty'),
             download: (project, id, key, options) => call('hives_download_object_by_key', { ...ids(project, id), key_base64url: hivesObjectKey(key) }, options, 'binary', HIVES_OBJECT_BYTES),
@@ -130,14 +148,14 @@ export function hivesCells(client) {
                 if (!/^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(key))
                     throw resourceError(0);
                 const body = await hivesObjectBody(bytes);
-                return acknowledgement(await write('hives_upload_object', { ...ids(project, id), key, body, content_type: hivesContentType(options.content_type) }, options), key, id, body.byteLength);
+                return acknowledgement(await write('hives_upload_object', { ...ids(project, id), key, body, content_type: hivesContentType(options.content_type) }, options), key, id, body.byteLength, 'hives_upload_object');
             },
             removeFlat: (project, id, key, options) => { hivesObjectKey(key); if (!/^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(key))
                 throw resourceError(0); return call('hives_delete_object', { ...ids(project, id), key }, options, 'empty'); },
             /** The flat key "download" on its own static route, which shadows /objects/{key} for that key. */
             async putDownload(project, id, bytes, options = {}) {
                 const body = await hivesObjectBody(bytes);
-                return acknowledgement(await write('hives_upload_object_named_download', { ...ids(project, id), body, content_type: hivesContentType(options.content_type) }, options), 'download', id, body.byteLength);
+                return acknowledgement(await write('hives_upload_object_named_download', { ...ids(project, id), body, content_type: hivesContentType(options.content_type) }, options), 'download', id, body.byteLength, 'hives_upload_object_named_download');
             },
             removeDownload: (project, id, options) => call('hives_delete_object_named_download', ids(project, id), options, 'empty'),
         },

package/dist/hives-node.d.ts

@@ -2,6 +2,8 @@ import { Genesis } from './genesis.js';
 import type { GenesisOptions } from './client.js';
 export declare function closeHivesNodeTransport(): Promise<void>;
 export declare function hivesOperationBudget(id: string): number;
+/** Live log streams must start within 45 s (15 s heartbeat + 15 s window + margin). The 330 s budget runs from the start of the request, so the body gets at least 285 s. */
+export declare function hivesHeaderBudget(id: string): number | undefined;
 /** Hives leaf transport. Caller fetch overrides stay authoritative; only native
  * global fetch gets our Agent. Every operation retains an overall body deadline. */
 export declare function createHivesNodeTransport(opts?: GenesisOptions, callerSignal?: AbortSignal): typeof fetch;

package/dist/hives-node.js

@@ -25,6 +25,10 @@ export function hivesOperationBudget(id) {
         return 100_000;
     return 20_000;
 }
+/** Live log streams must start within 45 s (15 s heartbeat + 15 s window + margin). The 330 s budget runs from the start of the request, so the body gets at least 285 s. */
+export function hivesHeaderBudget(id) {
+    return id === 'hives_stream_logs' || id === 'hives_stream_deployment_logs' ? 45_000 : undefined;
+}
 const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 const templatePattern = (value) => new RegExp('^' + value.split(/(\{[^}]+\})/).map((part) => part.startsWith('{') ? '[^/]+' : escape(part)).join('') + '$');
 /** Hives leaf transport. Caller fetch overrides stay authoritative; only native
@@ -79,6 +83,12 @@ export function createHivesNodeTransport(opts = {}, callerSignal) {
             controller.abort();
         }, hivesOperationBudget(route.id));
         timer.unref();
+        const headerBudget = hivesHeaderBudget(route.id);
+        const headerTimer = headerBudget === undefined ? undefined : setTimeout(() => {
+            message = 'Hives stream did not start within 45 s. Retry the stream.';
+            controller.abort();
+        }, headerBudget);
+        headerTimer?.unref();
         let abortReject = () => { };
         let reader;
         let bodyController;
@@ -93,6 +103,7 @@ export function createHivesNodeTransport(opts = {}, callerSignal) {
         void abortPromise.catch(() => { });
         const cleanup = () => {
             clearTimeout(timer);
+            clearTimeout(headerTimer);
             for (const signal of signals)
                 signal.removeEventListener('abort', canceled);
             controller.signal.removeEventListener('abort', aborted);
@@ -113,6 +124,7 @@ export function createHivesNodeTransport(opts = {}, callerSignal) {
             void pending.then((response) => { if (controller.signal.aborted)
                 void response.body?.cancel().catch(() => { }); }, () => { });
             const response = await Promise.race([pending, abortPromise]);
+            clearTimeout(headerTimer);
             if (controller.signal.aborted)
                 throw safeError();
             if (!response.body) {

package/dist/hives-operations.d.ts

@@ -31,16 +31,16 @@ export declare function hivesOperations(client: GenesisClient): {
             }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesObjectList>;
             put(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
                 content_type?: string;
-            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement | import("./hives-cells.js").HivesStorageWriteReplay>;
             remove: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
             download: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<Response>;
             putFlat(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
                 content_type?: string;
-            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement | import("./hives-cells.js").HivesStorageWriteReplay>;
             removeFlat: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
             putDownload(project: string, id: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
                 content_type?: string;
-            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement | import("./hives-cells.js").HivesStorageWriteReplay>;
             removeDownload: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
         };
         presign(project: string, id: string, body: import("./hives-cells.js").HivesPresign, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesPresignedUrl>;

package/dist/hives-project.d.ts

@@ -0,0 +1,19 @@
+import { GenesisError } from './errors.js';
+import type { OperationMeta } from './types.js';
+/** The one description of a Hives `project_id` (spec, CLI help and MCP schemas). */
+export declare const HIVES_PROJECT_ID_DESCRIPTION = "Hives project id (prj_\u2026)";
+/** Appended where an omitted project_id resolves from the selected Genesis context. */
+export declare const HIVES_PROJECT_ID_DEFAULT = "omit it to use the Hives project bound to your selected Genesis context";
+/** A Genesis project id (`pr_…`). A Hives project id is `prj_…`, so the two never collide. */
+export declare const isGenesisProjectId: (value: unknown) => value is string;
+/** Hives operations addressed by a Hives project in their path. */
+export declare const isHivesProjectOperation: (op: OperationMeta | undefined) => boolean;
+/** A Genesis pr_… id given where Hives wants its own prj_… id: refused before any request. */
+export declare function hivesProjectIdRefusal(value: string, operationId?: string): GenesisError;
+/**
+ * Map a Hives project argument to a Hives project id. A prj_… (or any non-Genesis) value is returned unchanged.
+ * Omitted, or a Genesis pr_… id that is the selected context's project, resolves to that selection's Hives binding
+ * read from `hives_get_context_project`; anything else is refused with how to find the prj_… id. When the binding
+ * came from a cache and a pr_… id does not match it, `reread` (if given) reads the selection once more before refusing.
+ */
+export declare function resolveHivesProjectId(value: unknown, readContext: () => Promise<unknown>, reread?: () => Promise<unknown> | undefined): Promise<string>;

package/dist/hives-project.js

@@ -0,0 +1,62 @@
+import { GenesisError } from './errors.js';
+/** The one description of a Hives `project_id` (spec, CLI help and MCP schemas). */
+export const HIVES_PROJECT_ID_DESCRIPTION = 'Hives project id (prj_…)';
+/** Appended where an omitted project_id resolves from the selected Genesis context. */
+export const HIVES_PROJECT_ID_DEFAULT = 'omit it to use the Hives project bound to your selected Genesis context';
+/** A Genesis project id (`pr_…`). A Hives project id is `prj_…`, so the two never collide. */
+export const isGenesisProjectId = (value) => typeof value === 'string' && /^pr_[A-Za-z0-9]{1,124}$/.test(value);
+const HIVES_PROJECT = /^prj_[A-Za-z0-9]{1,124}$/;
+/** Hives operations addressed by a Hives project in their path. */
+export const isHivesProjectOperation = (op) => op?.service === 'hives' && op.pathParams.includes('project_id');
+const FIND = 'Find the Hives project bound to your selected Genesis context with `genesis hives context get` (SDK: genesis.hives.resolveProject()), or list Hives projects with `genesis hives projects list`.';
+/** A Genesis pr_… id given where Hives wants its own prj_… id: refused before any request. */
+export function hivesProjectIdRefusal(value, operationId) {
+    return new GenesisError({ status: 0, type: 'invalid_request', code: 'HIVES_PROJECT_ID_REQUIRED', operationId,
+        message: `${value} is a Genesis project id. Hives operations take a Hives project id (prj_…). ${FIND}` });
+}
+const notBound = (message, from) => new GenesisError({ status: from?.status ?? 0, type: 'invalid_request', code: 'HIVES_PROJECT_NOT_BOUND',
+    message, requestId: from?.requestId, operationId: 'hives_get_context_project' });
+/**
+ * Map a Hives project argument to a Hives project id. A prj_… (or any non-Genesis) value is returned unchanged.
+ * Omitted, or a Genesis pr_… id that is the selected context's project, resolves to that selection's Hives binding
+ * read from `hives_get_context_project`; anything else is refused with how to find the prj_… id. When the binding
+ * came from a cache and a pr_… id does not match it, `reread` (if given) reads the selection once more before refusing.
+ */
+export async function resolveHivesProjectId(value, readContext, reread) {
+    if (value !== undefined && value !== null && value !== '' && !isGenesisProjectId(value)) {
+        if (typeof value !== 'string')
+            throw new GenesisError({ status: 0, type: 'invalid_request', code: 'HIVES_PROJECT_ID_REQUIRED', message: `project_id must be a ${HIVES_PROJECT_ID_DESCRIPTION}.` });
+        return value;
+    }
+    const load = async (read) => {
+        try {
+            return binding(await read());
+        }
+        catch (e) {
+            if (!(e instanceof GenesisError) || ![404, 409].includes(e.status))
+                throw e;
+            const named = isGenesisProjectId(value) ? `${value} is a Genesis project id and ` : '';
+            throw notBound(e.status === 404
+                ? `${named}No Hives project is bound to your selected Genesis context. Bind one with \`genesis hives context create <name>\` or \`genesis hives context link <prj_…>\`, or pass a Hives project id (prj_…) from \`genesis hives projects list\`.`
+                : `${named}No Genesis project is selected. Select an organization, workspace and project with \`genesis context select\`, or pass a Hives project id (prj_…) from \`genesis hives projects list\`.`, e);
+        }
+    };
+    let { selected, bound } = await load(readContext);
+    if (isGenesisProjectId(value) && value !== selected && reread) {
+        const fresh = reread();
+        if (fresh)
+            ({ selected, bound } = await load(() => fresh));
+    }
+    if (isGenesisProjectId(value) && value !== selected) {
+        throw notBound(`${value} is a Genesis project id, and it is not your selected Genesis project (${selected}, bound to Hives project ${bound}). Select it with \`genesis context select\`, or pass its Hives project id (prj_…) from \`genesis hives projects list\`.`);
+    }
+    return bound;
+}
+function binding(context) {
+    const row = context && typeof context === 'object' ? context : {};
+    const selected = row.selectedContext?.projectId, bound = row.binding?.hivesProjectId;
+    if (typeof bound !== 'string' || !HIVES_PROJECT.test(bound) || typeof selected !== 'string') {
+        throw new GenesisError({ status: 0, type: 'invalid_response', operationId: 'hives_get_context_project', message: 'Hives returned an invalid context binding.' });
+    }
+    return { selected, bound };
+}

package/dist/hives-sse.d.ts

@@ -7,7 +7,7 @@ export interface HivesSseEvent {
 export interface HivesSseWindowOptions {
     /** Stop after this many events (1-1000, default 100). */
     maxEvents?: number;
-    /** Stop after this many seconds (1-15, default 10). The CLI and MCP Hives node transport allows a body 20 s, so a window stays below it. */
+    /** Stop after this many seconds (1-15, default 10). The CLI and MCP Hives node transport waits at most 45 s for a log stream to start, within a 330 s budget from the start of the request (at least 285 s of body), so a window always fits. */
     seconds?: number;
     signal?: AbortSignal;
 }

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export type { paths, operations, components } from './generated/schema.js';
 export { hivesUploadBody, MAX_WASM_BYTES, type HivesUploadOptions } from './hives-upload.js';
 export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationError, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES, type HivesInvokeRequest, type HivesInvokeOptions, type HivesOperationStatus } from './hives-functions.js';
 export { hivesResponseBytes } from './hives-response.js';
+export { HIVES_PROJECT_ID_DESCRIPTION, HIVES_PROJECT_ID_DEFAULT, isGenesisProjectId, isHivesProjectOperation, hivesProjectIdRefusal } from './hives-project.js';
 export { runnerModule, type RunnerStartInput, type RunnerSnapshot, type RunnerCatalog, type RunnerEvent, type RunnerProviderResult, type RunnerRequestOptions } from './runner.js';
 export type { RunnerSelfExecutionGrantInput, RunnerSelfExecutionGrant } from './runner-grant.js';
 export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS, type BeaconsResourceFamily } from './beacons.js';
@@ -29,7 +30,7 @@ export { scopesModule } from './scopes.js';
 export { billingModule, gatewayModule, orgsModule } from './gateway.js';
 export { boxesModule } from './boxes.js';
 export { dialsModule, dialsEmergencyAddressFeedback, type DialsEmergencyAddressFeedback, type DialsScope, type DialsOutboundCall, type DialsCallControl, type DialsEmergencyAddress, type DialsCallListItem, type DialsCallDispatchState, type DialsMessage, type DialsMessageTemplate, type DialsMessagingBrand, type DialsMessagingCampaign, type DialsWorkflowDocument, type DialsRoutingAction, type DialsRoutingRule, type DialsRoutingRuleReceipt, type DialsOutboundCallReceipt, type DialsRecoveredOutboundCallReceipt } from './dials.js';
-export { hivesObjectKey, type HivesBucket, type HivesObject, type HivesObjectAcknowledgement, type HivesObjectList, type HivesCorsRule, type HivesCreateBucket, type HivesPresign, type HivesPresignedUrl } from './hives-cells.js';
+export { hivesObjectKey, type HivesBucket, type HivesObject, type HivesObjectAcknowledgement, type HivesStorageWriteReplay, type HivesObjectList, type HivesCorsRule, type HivesCreateBucket, type HivesPresign, type HivesPresignedUrl } from './hives-cells.js';
 export { hivesSseEvents, hivesSseReader, type HivesLogStreamEvent, type HivesLogStreamQuery, type HivesLogWindow, type HivesLogWindowOptions } from './hives-platform.js';
 export { hivesQueueBody, type HivesQueue, type HivesQueueConfig, type HivesQueueCreate, type HivesQueueSend, type HivesQueueDelivery, type HivesDeadLetter, type HivesDeadLetterStats } from './hives-queues.js';
 export type { HivesRuntime, HivesRuntimeSelection } from './hives-runtimes.js';

package/dist/index.js

@@ -9,6 +9,7 @@ export { operationTable, services } from './generated/operations.js';
 export { hivesUploadBody, MAX_WASM_BYTES } from './hives-upload.js';
 export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationError, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES } from './hives-functions.js';
 export { hivesResponseBytes } from './hives-response.js';
+export { HIVES_PROJECT_ID_DESCRIPTION, HIVES_PROJECT_ID_DEFAULT, isGenesisProjectId, isHivesProjectOperation, hivesProjectIdRefusal } from './hives-project.js';
 export { runnerModule } from './runner.js';
 export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS } from './beacons.js';
 export { rigsModule, panesModule, shellsModule } from './instances.js';

package/dist/minds.js

@@ -35,7 +35,7 @@ export async function mindsTransport(options) {
     const id = options.operationId, input = options.input, write = writes.has(id);
     let dispatchAttempted = false;
     const error = (status, type, code, unknownOutcome = false) => new GenesisError({ status, type, code, operationId: id,
-        message: status === 403 ? code === 'HUMAN_SANDBOX_SELECTION_REQUIRED'
+        message: status === 410 ? 'This Mind was deleted; its data is archived. It cannot be resumed or used.' : status === 403 ? code === 'HUMAN_SANDBOX_SELECTION_REQUIRED'
             ? 'HUMAN_SANDBOX_SELECTION_REQUIRED: Minds accepts an original human One account session with a Console Sandbox selection, or organization API keys with a selected (bound) context; M2M tokens are refused.'
             : code === 'SCOPE_MISSING' ? 'SCOPE_MISSING: this organization API key lacks the Minds scope the operation needs (minds:read, minds:write or minds:manage; minds:manage does not imply read).'
                 : 'Minds requires an admitted original human One account session with a Console Sandbox selection, or an organization API key with the operation\'s Minds scope.'
@@ -182,7 +182,7 @@ export async function mindsTransport(options) {
             const code = detail && Object.hasOwn(detail, 'code') && typeof detail.code === 'string' ? detail.code : undefined;
             const unknownOutcome = lifecycle.includes(id) && response.status === 401 && code === 'SELECTION_EXPIRED'
                 && detail !== undefined && Object.hasOwn(detail, 'outcome') && detail.outcome === 'unknown';
-            throw error(response.status, 'minds_error', code, unknownOutcome || id === 'minds_createWebhookDelivery' && detail?.outcome === 'unknown');
+            throw error(response.status, response.status === 410 ? 'gone' : 'minds_error', code, unknownOutcome || id === 'minds_createWebhookDelivery' && detail?.outcome === 'unknown');
         }
         if (['minds_createMind', ...lifecycle, 'minds_createWebhookDelivery'].includes(id) && response.status !== 202)
             throw error(response.status, 'invalid_response');

package/dist/urls.js

@@ -41,34 +41,54 @@ const ENCODED_USERINFO = /(%(?:25){0,2}2F%(?:25){0,2}2F)(?:(?!%(?:25){0,2}2F)[^\
 const BARE_USERINFO = /(^|[\s"'(<=,;[{])[^\s/?#@＠:"'<>\\]{1,64}:[^\s/?#"'<>\\]{0,128}[@＠](?=[\w[])/g;
 /** Every place a userinfo can end: `@`, fullwidth `＠`, or an encoded `%40` / `%2540`. */
 const AT_HITS = /[@＠]|%(?:25){0,2}40/gi;
+/** The scheme-less form can only end at an `@` or `＠` that is followed by a word character or `[` (see BARE_USERINFO). */
+const BARE_HITS = /[@＠](?=[\w[])/g;
 /** The longest URL-form match (slashes and userinfo, encoded) is under 640 characters; the bare form is under 200. */
 const URL_WINDOW = 700;
 const BARE_WINDOW = 200;
-/** Apply `fn` to the stretches of `text` within `window` characters before an `@`-like hit, and copy the rest as it is. */
-function overHits(text, window, fn) {
-    AT_HITS.lastIndex = 0;
-    let hit = AT_HITS.exec(text);
-    if (!hit)
+/** With at least one hit per DENSE characters the windows would cover the text anyway, so it is scanned whole. The regexes are linear on their own; the windows only skip stretches that cannot hold a userinfo. */
+const DENSE = 64;
+/** Start and end of every hit of `re` in `text`, flattened; `null` when they are dense. */
+function hitSpans(text, re) {
+    const limit = Math.floor(text.length / DENSE);
+    const spans = [];
+    re.lastIndex = 0;
+    for (let hit = re.exec(text); hit; hit = re.exec(text)) {
+        if (spans.length >= 2 * limit)
+            return null;
+        spans.push(hit.index, hit.index + hit[0].length);
+    }
+    return spans;
+}
+/**
+ * Apply `fn` to the stretches of `text` within `window` characters before a hit, and copy the rest as it is.
+ * `spans` of `null` means dense: `fn` runs over the whole text. A stretch without the character `needs` cannot hold a match.
+ */
+function overHits(text, spans, window, fn, needs = '') {
+    if (spans === null)
+        return fn(text);
+    if (spans.length === 0)
         return text;
     let out = '';
     let copied = 0;
-    let start = Math.max(0, hit.index - window);
-    let end = hit.index + hit[0].length + 1;
+    let start = Math.max(0, spans[0] - window);
+    let end = spans[1] + 1;
     const flush = () => {
+        const seg = text.slice(start, end);
         // A sentinel before a window that does not start the text keeps `^` (start of text) from matching mid-text.
-        const piece = start > 0 ? fn(`x${text.slice(start, end)}`).slice(1) : fn(text.slice(start, end));
+        const piece = needs && !seg.includes(needs) ? seg : start > 0 ? fn(`x${seg}`).slice(1) : fn(seg);
         out += text.slice(copied, start) + piece;
         copied = Math.min(end, text.length);
     };
-    for (hit = AT_HITS.exec(text); hit; hit = AT_HITS.exec(text)) {
-        const s = Math.max(0, hit.index - window);
+    for (let i = 2; i < spans.length; i += 2) {
+        const s = Math.max(0, spans[i] - window);
         if (s <= end) {
-            end = hit.index + hit[0].length + 1;
+            end = spans[i + 1] + 1;
             continue;
         }
         flush();
         start = s;
-        end = hit.index + hit[0].length + 1;
+        end = spans[i + 1] + 1;
     }
     flush();
     return out + text.slice(copied);
@@ -83,8 +103,10 @@ export function redactUserinfo(text, mask = '***') {
     // Pre-check: no `@`, `＠` or `%40` means no userinfo in any form.
     if (!/[@＠]|%(?:25){0,2}40/i.test(text))
         return text;
-    const urlForms = overHits(text, URL_WINDOW, (t) => t.replace(ENCODED_USERINFO, `$1${mask}%40`).replace(USERINFO, `$1${mask}@`));
-    return overHits(urlForms, BARE_WINDOW, (t) => t.replace(BARE_USERINFO, `$1${mask}@`));
+    const urlForms = overHits(text, hitSpans(text, AT_HITS), URL_WINDOW, (t) => t.replace(ENCODED_USERINFO, `$1${mask}%40`).replace(USERINFO, `$1${mask}@`));
+    if (!urlForms.includes(':'))
+        return urlForms; // the scheme-less form needs its colon
+    return overHits(urlForms, hitSpans(urlForms, BARE_HITS), BARE_WINDOW, (t) => t.replace(BARE_USERINFO, `$1${mask}@`), ':');
 }
 /** `url` without its userinfo (`https://u:p@host/x` becomes `https://host/x`); text that is not an absolute URL passes through redactUserinfo. */
 export function stripUserinfo(url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onesi/genesis",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/l1felabs/genesis-api.git",