@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/hives-topics.d.ts

@@ -0,0 +1,51 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+export interface HivesTopic {
+    id: string;
+    projectId: string;
+    name: string;
+    createdAt: string;
+}
+export interface HivesTopicSubscription {
+    id: string;
+    projectId: string;
+    topicId: string;
+    queueId: string;
+    createdAt: string;
+}
+export interface HivesTopicPublish {
+    body?: unknown;
+    body_base64?: string;
+    attributes?: Record<string, string>;
+}
+export interface HivesTopicPublication {
+    publication_id: string;
+    deliveries: {
+        subscription_id: string;
+        queue_id: string;
+        message_id: string;
+    }[];
+}
+export declare function hivesTopics(client: GenesisClient): {
+    list(project: string, options?: HivesResourceOptions): Promise<{
+        data: HivesTopic[];
+    }>;
+    get(project: string, id: string, options?: HivesResourceOptions): Promise<HivesTopic>;
+    create(project: string, body: {
+        name: string;
+    }, options?: HivesResourceOptions): Promise<HivesTopic>;
+    remove(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        deleted: true;
+    }>;
+    subscriptions: {
+        list(project: string, id: string, options?: HivesResourceOptions): Promise<{
+            data: HivesTopicSubscription[];
+        }>;
+        add(project: string, id: string, queueId: string, options?: HivesResourceOptions): Promise<HivesTopicSubscription>;
+        remove(project: string, id: string, subscriptionId: string, options?: HivesResourceOptions): Promise<{
+            deleted: true;
+        }>;
+    };
+    /** Persists one delivery per subscription atomically. Never retried after an unknown outcome. */
+    publish(project: string, id: string, body: HivesTopicPublish, options?: HivesResourceOptions): Promise<HivesTopicPublication>;
+};

package/dist/hives-topics.js

@@ -0,0 +1,79 @@
+import { hivesQueueBody } from './hives-queues.js';
+import { HIVES_QUEUE_BYTES, hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+const invalid = () => resourceError(0);
+const object = (v) => { if (!v || typeof v !== 'object' || Array.isArray(v))
+    throw invalid(); return v; };
+function nativeId(value, prefix) { if (typeof value !== 'string' || !new RegExp(`^${prefix}_[a-f0-9]{32}$`).test(value))
+    throw invalid(); return value; }
+function date(value) { if (typeof value !== 'string' || !Number.isFinite(Date.parse(value)))
+    throw invalid(); return value; }
+function name(value) { if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
+    throw invalid(); return value; }
+function topic(value, project, id) {
+    const v = object(value);
+    if (v.projectId !== project || id !== undefined && v.id !== id)
+        throw invalid();
+    return { id: nativeId(v.id, 'top'), projectId: project, name: name(v.name), createdAt: date(v.createdAt) };
+}
+function subscription(value, project, topicId, queueId) {
+    const v = object(value);
+    if (v.projectId !== project || v.topicId !== topicId || queueId !== undefined && v.queueId !== queueId)
+        throw invalid();
+    return { id: nativeId(v.id, 'sub'), projectId: project, topicId, queueId: hivesResourceId(v.queueId), createdAt: date(v.createdAt) };
+}
+function publishInput(value) {
+    const v = object(value);
+    if (Object.keys(v).some(k => !['body', 'body_base64', 'attributes'].includes(k)) || (v.body != null) === (v.body_base64 != null))
+        throw invalid();
+    if (v.body_base64 != null)
+        hivesQueueBody(v.body_base64);
+    else {
+        let encoded;
+        try {
+            encoded = typeof v.body === 'string' ? v.body : JSON.stringify(v.body);
+        }
+        catch {
+            throw invalid();
+        }
+        if (encoded === undefined || new TextEncoder().encode(encoded).length > HIVES_QUEUE_BYTES)
+            throw invalid();
+    }
+    if (v.attributes !== undefined) {
+        const attrs = object(v.attributes);
+        if (Object.keys(attrs).length > 61 || Object.entries(attrs).some(([k, a]) => !k || new TextEncoder().encode(k).length > 128 || k.startsWith('buzz.') || typeof a !== 'string') || new TextEncoder().encode(JSON.stringify(attrs)).length > 8192)
+            throw invalid();
+    }
+}
+export function hivesTopics(client) {
+    const ids = (project, id) => ({ project_id: hivesResourceId(project), ...(id === undefined ? {} : { topic_id: hivesResourceId(id) }) });
+    const call = (operation, input, options, status = 200) => hivesResourceCall(client, operation, input, options, 'json', 2 * 1024 * 1024, 20_000, status);
+    const removed = (value) => { if (object(value).deleted !== true)
+        throw invalid(); return { deleted: true }; };
+    return {
+        async list(project, options) { const v = object(await call('hives_list_native_topic', ids(project), options)); if (!Array.isArray(v.data) || v.data.length > 16)
+            throw invalid(); const data = v.data.map(row => topic(row, project)); if (new Set(data.map(x => x.id)).size !== data.length)
+            throw invalid(); return { data }; },
+        async get(project, id, options) { return topic(await call('hives_inspect_native_topic', ids(project, id), options), project, id); },
+        async create(project, body, options) { const v = object(body); if (Object.keys(v).length !== 1)
+            throw invalid(); name(v.name); return topic(await call('hives_create_native_topic', { ...ids(project), body }, options, 201), project); },
+        async remove(project, id, options) { return removed(await call('hives_delete_native_topic', ids(project, id), options)); },
+        subscriptions: {
+            async list(project, id, options) { const v = object(await call('hives_subscriptions_native_topic', ids(project, id), options)); if (!Array.isArray(v.data) || v.data.length > 32)
+                throw invalid(); const data = v.data.map(row => subscription(row, project, id)); if (new Set(data.map(x => x.id)).size !== data.length || new Set(data.map(x => x.queueId)).size !== data.length)
+                throw invalid(); return { data }; },
+            async add(project, id, queueId, options) { const queue = hivesResourceId(queueId); return subscription(await call('hives_subscribe_native_topic', { ...ids(project, id), body: { queueId: queue } }, options, 201), project, id, queue); },
+            async remove(project, id, subscriptionId, options) { return removed(await call('hives_unsubscribe_native_topic', { ...ids(project, id), subscription_id: hivesResourceId(subscriptionId) }, options)); },
+        },
+        /** Persists one delivery per subscription atomically. Never retried after an unknown outcome. */
+        async publish(project, id, body, options) {
+            publishInput(body);
+            const v = object(await call('hives_publish_native_topic', { ...ids(project, id), body }, options, 201));
+            if (!Array.isArray(v.deliveries) || v.deliveries.length > 32)
+                throw invalid();
+            const deliveries = v.deliveries.map(raw => { const d = object(raw); return { subscription_id: nativeId(d.subscription_id, 'sub'), queue_id: hivesResourceId(d.queue_id), message_id: hivesResourceId(d.message_id) }; });
+            if (new Set(deliveries.map(x => x.subscription_id)).size !== deliveries.length || new Set(deliveries.map(x => x.queue_id)).size !== deliveries.length || new Set(deliveries.map(x => x.message_id)).size !== deliveries.length)
+                throw invalid();
+            return { publication_id: nativeId(v.publication_id, 'pub'), deliveries };
+        },
+    };
+}

package/dist/hives-upload.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_WASM_BYTES: number;
+export interface HivesUploadOptions {
+    filename?: string;
+    git_sha?: string;
+    git_branch?: string;
+    git_message?: string;
+}
+/** Real multipart binary; the org and digest are resolved by the authenticated backend. */
+export declare function hivesUploadBody(file: Blob, options?: HivesUploadOptions): Promise<FormData>;

package/dist/hives-upload.js

@@ -0,0 +1,23 @@
+export const MAX_WASM_BYTES = 10 * 1024 * 1024;
+/** Real multipart binary; the org and digest are resolved by the authenticated backend. */
+export async function hivesUploadBody(file, options = {}) {
+    if (!(file instanceof Blob) || file.size < 4 || file.size > MAX_WASM_BYTES)
+        throw new Error('Choose a WebAssembly binary of 4 bytes to 10 MiB.');
+    const magic = new Uint8Array(await file.slice(0, 4).arrayBuffer());
+    if (magic[0] !== 0 || magic[1] !== 97 || magic[2] !== 115 || magic[3] !== 109)
+        throw new Error('The file must be a WebAssembly binary.');
+    const limits = { git_sha: 40, git_branch: 255, git_message: 1000 };
+    if (options.filename !== undefined && (typeof options.filename !== 'string' || !options.filename.length || options.filename.length > 255 || /[\r\n]/.test(options.filename)))
+        throw new Error('WASM filename must contain 1–255 characters without newlines.');
+    const form = new FormData();
+    form.append('file', file, options.filename ?? 'module.wasm');
+    for (const key of Object.keys(limits)) {
+        const value = options[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'string' || value.length > limits[key] || (key === 'git_sha' && value.length < 7))
+            throw new Error('Invalid deployment Git metadata.');
+        form.append(key, value);
+    }
+    return form;
+}

package/dist/hives-volumes.d.ts

@@ -0,0 +1,64 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+declare const states: readonly ["creating", "available", "attaching", "attached", "detaching", "deleting", "failed"];
+export interface HivesVolume {
+    id: string;
+    project_id: string;
+    name: string;
+    size_gib: number;
+    backing_bytes: number;
+    capacity_bytes: number | null;
+    used_bytes: number | null;
+    storage_class: 'local';
+    access_mode: 'read_write_once';
+    state: typeof states[number];
+    operation_pending: boolean;
+    generation: number;
+    mount_path: string | null;
+    attached_to: string | null;
+    read_only: boolean | null;
+    created_at: string;
+    updated_at: string;
+}
+export type HivesVolumeCreate = {
+    name: string;
+    storage_class?: 'local';
+    access_mode?: 'read_write_once';
+} & ({
+    size_mib: number;
+    size_gib?: never;
+} | {
+    size_gib: 1;
+    size_mib?: never;
+});
+export interface HivesVolumeMount {
+    target_id: string;
+    mount_path: string;
+    read_only: boolean;
+}
+export interface HivesVolumePage {
+    volumes: HivesVolume[];
+    pagination: {
+        page: number;
+        per_page: number;
+        total: number;
+        total_pages: number;
+    };
+}
+/** Persisted project storage. A failed acknowledgement never triggers an automatic write retry. */
+export declare function hivesVolumes(client: GenesisClient): {
+    list(project: string, query?: {
+        page?: number;
+        per_page?: number;
+    }, options?: HivesResourceOptions): Promise<HivesVolumePage>;
+    get(project: string, id: string, options?: HivesResourceOptions): Promise<HivesVolume>;
+    create(project: string, input: HivesVolumeCreate, options?: HivesResourceOptions): Promise<HivesVolume>;
+    mount(project: string, id: string, input: HivesVolumeMount, options?: HivesResourceOptions): Promise<HivesVolume>;
+    unmount(project: string, id: string, options?: HivesResourceOptions): Promise<HivesVolume>;
+    remove(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        success: true;
+        id: string;
+        message: string;
+    }>;
+};
+export {};

package/dist/hives-volumes.js

@@ -0,0 +1,117 @@
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+const MIB = 1024 * 1024;
+const states = ['creating', 'available', 'attaching', 'attached', 'detaching', 'deleting', 'failed'];
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw resourceError(0);
+    return value;
+}
+function text(value, max = 128) {
+    if (typeof value !== 'string' || !value || value.length > max || /[\u0000-\u001f\u007f]/.test(value))
+        throw resourceError(0);
+    return value;
+}
+function count(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw resourceError(0);
+    return value;
+}
+function date(value) { const result = text(value, 64); if (!Number.isFinite(Date.parse(result)))
+    throw resourceError(0); return result; }
+function volume(value, project, expectedId) {
+    const row = object(value);
+    if (row.project_id !== project || row.storage_class !== 'local' || row.access_mode !== 'read_write_once'
+        || !states.includes(row.state) || typeof row.operation_pending !== 'boolean')
+        throw resourceError(0);
+    const id = hivesResourceId(text(row.id));
+    if (expectedId && id !== expectedId)
+        throw resourceError(0);
+    const backing = count(row.backing_bytes);
+    const capacity = row.capacity_bytes === null ? null : count(row.capacity_bytes);
+    const used = row.used_bytes === null ? null : count(row.used_bytes);
+    if (backing < 32 * MIB || backing > 1024 * MIB || row.size_gib !== backing / (1024 * MIB)
+        || capacity !== null && capacity > backing || used !== null && (capacity === null || used > capacity))
+        throw resourceError(0);
+    const path = row.mount_path === null ? null : text(row.mount_path, 512);
+    const attached = row.attached_to === null ? null : hivesResourceId(text(row.attached_to));
+    if ((path === null) !== (attached === null) || (attached === null ? row.read_only !== null : typeof row.read_only !== 'boolean'))
+        throw resourceError(0);
+    const generation = count(row.generation);
+    if (generation < 1)
+        throw resourceError(0);
+    return { id, project_id: project, name: text(row.name, 64), size_gib: backing / (1024 * MIB), backing_bytes: backing,
+        capacity_bytes: capacity, used_bytes: used, storage_class: 'local', access_mode: 'read_write_once',
+        state: row.state, operation_pending: row.operation_pending, generation,
+        mount_path: path, attached_to: attached, read_only: row.read_only,
+        created_at: date(row.created_at), updated_at: date(row.updated_at) };
+}
+/** Persisted project storage. A failed acknowledgement never triggers an automatic write retry. */
+export function hivesVolumes(client) {
+    const ids = (project, id) => ({ project_id: hivesResourceId(project), ...(id === undefined ? {} : { volume_id: hivesResourceId(id) }) });
+    const call = (id, input, options) => hivesResourceCall(client, id, input, options);
+    return {
+        async list(project, query = {}, options) {
+            const page = query.page ?? 1;
+            const perPage = query.per_page ?? 25;
+            if (Object.keys(query).some(key => !['page', 'per_page'].includes(key)) || !Number.isSafeInteger(page) || page < 1 || page > 10000
+                || !Number.isSafeInteger(perPage) || perPage < 1 || perPage > 100)
+                throw resourceError(0);
+            const result = object(await call('hives_list_volumes', { ...ids(project), page, per_page: perPage }, options));
+            const pagination = object(result.pagination);
+            const total = count(pagination.total);
+            const pages = count(pagination.total_pages);
+            if (pagination.page !== page || pagination.per_page !== perPage || pages !== Math.ceil(total / perPage)
+                || !Array.isArray(result.volumes) || result.volumes.length > perPage)
+                throw resourceError(0);
+            const volumes = result.volumes.map(row => volume(row, project));
+            if (new Set(volumes.map(row => row.id)).size !== volumes.length)
+                throw resourceError(0);
+            return { volumes, pagination: { page, per_page: perPage, total, total_pages: pages } };
+        },
+        async get(project, id, options) { return volume(await call('hives_get_volume', ids(project, id), options), project, id); },
+        async create(project, input, options) {
+            const body = object(input);
+            const name = text(body.name, 64);
+            let size;
+            if (body.size_mib !== undefined && body.size_gib === undefined)
+                size = count(body.size_mib);
+            else if (body.size_mib === undefined && body.size_gib === 1)
+                size = 1024;
+            else
+                throw resourceError(0);
+            if (name.trim() !== name || size < 32 || size > 1024 || body.storage_class !== undefined && body.storage_class !== 'local'
+                || body.access_mode !== undefined && body.access_mode !== 'read_write_once'
+                || Object.keys(body).some(key => !['name', 'size_mib', 'size_gib', 'storage_class', 'access_mode'].includes(key)))
+                throw resourceError(0);
+            const result = volume(await call('hives_create_volume', { ...ids(project), body: { name, size_mib: size, storage_class: 'local', access_mode: 'read_write_once' } }, options), project);
+            if (result.name !== name || result.backing_bytes !== size * MIB)
+                throw resourceError(0);
+            return result;
+        },
+        async mount(project, id, input, options) {
+            const body = object(input);
+            const target = hivesResourceId(text(body.target_id));
+            const path = text(body.mount_path, 128);
+            if (!/^\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/.test(path) || typeof body.read_only !== 'boolean'
+                || Object.keys(body).some(key => !['target_id', 'mount_path', 'read_only'].includes(key)))
+                throw resourceError(0);
+            const readOnly = body.read_only;
+            const result = volume(await call('hives_mount_volume', { ...ids(project, id), body: { target_id: target, mount_path: path, read_only: readOnly } }, options), project, id);
+            if (result.attached_to !== target || result.mount_path !== path || result.read_only !== readOnly)
+                throw resourceError(0);
+            return result;
+        },
+        async unmount(project, id, options) {
+            const result = volume(await call('hives_unmount_volume', ids(project, id), options), project, id);
+            if (result.state !== 'available' || result.operation_pending || result.attached_to !== null || result.mount_path !== null || result.read_only !== null)
+                throw resourceError(0);
+            return result;
+        },
+        async remove(project, id, options) {
+            const result = object(await call('hives_delete_volume', ids(project, id), options));
+            if (result.id !== id || result.success !== true)
+                throw resourceError(0);
+            return { success: true, id, message: text(result.message, 256) };
+        },
+    };
+}

package/dist/idempotency.d.ts

@@ -0,0 +1,4 @@
+import { type OperationId } from './generated/operations.js';
+/** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
+ * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
+export declare function idempotencyHeaders(operationId: OperationId, key: string | undefined): Record<string, string>;

package/dist/idempotency.js

@@ -0,0 +1,17 @@
+import { GenesisError } from './errors.js';
+import { operationTable } from './generated/operations.js';
+const REQUIRED = /^[\x21-\x7e]{8,128}$/;
+const OPTIONAL = /^[\x21-\x7e]{1,256}$/;
+/** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
+ * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
+export function idempotencyHeaders(operationId, key) {
+    const need = operationTable[operationId].idempotencyKey;
+    if (key === undefined && need !== 'required')
+        return {};
+    if (!need || typeof key !== 'string' || !(need === 'required' ? REQUIRED : OPTIONAL).test(key)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+            message: need === 'required' ? `${operationId} needs a stable idempotency key (8-128 printable ASCII characters)`
+                : need ? `${operationId} idempotency key must be 1-256 printable ASCII characters` : `${operationId} does not take an idempotency key` });
+    }
+    return { 'idempotency-key': key };
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { Genesis, type ChatMessage } from './genesis.js';
+export { GenesisClient, DEFAULT_BASE_URL, type GenesisOptions, type CredentialProvider } from './client.js';
+export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
+export { requireSecureUrl } from './urls.js';
+export { operationTable, services, type OperationId } from './generated/operations.js';
+export type { OperationInput, OperationOutput, OperationMeta, ServiceMeta } from './types.js';
+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 { 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 } from './beacons.js';
+export { rigsModule, panesModule, shellsModule } from './instances.js';
+export { gearsModule } from './gears.js';
+export { lanesModule } from './lanes.js';
+export { flaresModule } from './flares.js';
+export { idempotencyHeaders } from './idempotency.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 { 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';
+export type { HivesVolume, HivesVolumeCreate, HivesVolumeMount, HivesVolumePage } from './hives-volumes.js';
+export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES, type HivesResourceOptions } from './hives-resources-transport.js';
+export type { HivesMarketplacePackage, HivesMarketplaceVersion, HivesMarketplaceInstallation, HivesMarketplaceCategory, HivesMarketplacePage, HivesMarketplacePublish, HivesMarketplaceInstall, HivesMarketplaceSearch, HivesMarketplaceDetail } from './hives-marketplace.js';
+export type { HivesQueueConsumerConfig, HivesQueueConsumerBinding, HivesQueueConsumerAttempt, HivesQueueConsumerStatus } from './hives-queue-consumer.js';
+export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
+export type { HivesTopic, HivesTopicSubscription, HivesTopicPublish, HivesTopicPublication } from './hives-topics.js';
+export { mindsModule, mindsOperations, isMindsOperation, type MindsCreateOptions, type MindsResumeOptions, type MindsStopOptions, type MindsWakeReason, type MindsRequestOptions, type MindsUsage, type MindsEventInput } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, type MindsAgentOptions, type MindsAgentEventInput } from './minds-agent.js';
+export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation, type MindsOwnerOptions, type MindsOwnerVersion, type MindsAttachmentSubject, type MindsAttachInput } from './minds-owner.js';
+export { selectGenesisContext, checkedGenesisContextSession, type GenesisContextSelection, type GenesisContextSession } from './context.js';
+export { HivesQueueOperationError, hivesQueueOperationId, type HivesQueueOperation, type HivesQueueSendOptions } from './hives-queue-funding.js';

package/dist/index.js

@@ -0,0 +1,25 @@
+export { Genesis } from './genesis.js';
+export { GenesisClient, DEFAULT_BASE_URL } from './client.js';
+export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
+export { requireSecureUrl } from './urls.js';
+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 { runnerModule } from './runner.js';
+export { beaconsModule } from './beacons.js';
+export { rigsModule, panesModule, shellsModule } from './instances.js';
+export { gearsModule } from './gears.js';
+export { lanesModule } from './lanes.js';
+export { flaresModule } from './flares.js';
+export { idempotencyHeaders } from './idempotency.js';
+export { dialsModule, dialsEmergencyAddressFeedback } from './dials.js';
+export { hivesObjectKey } from './hives-cells.js';
+export { hivesQueueBody } from './hives-queues.js';
+export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES } from './hives-resources-transport.js';
+export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
+export { mindsModule, mindsOperations, isMindsOperation } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation } from './minds-agent.js';
+export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation } from './minds-owner.js';
+export { selectGenesisContext, checkedGenesisContextSession } from './context.js';
+export { HivesQueueOperationError, hivesQueueOperationId } from './hives-queue-funding.js';

package/dist/instances.d.ts

@@ -0,0 +1,25 @@
+import type { GenesisClient } from './client.js';
+/** Read-only instance inventories. Each needs an interactive One account login with a selected
+ * organization and project; the gateway admits nothing else on these products. */
+export declare function rigsModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "rigs";
+        instances: import("./index.js").components["schemas"]["Rigs.Instance"][];
+    }>;
+};
+export declare function panesModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "panes";
+        instances: import("./index.js").components["schemas"]["Panes.Instance"][];
+    } & {
+        [key: string]: unknown;
+    }>;
+};
+export declare function shellsModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "shells";
+        instances: import("./index.js").components["schemas"]["Shells.Instance"][];
+    } & {
+        [key: string]: unknown;
+    }>;
+};

package/dist/instances.js

@@ -0,0 +1,11 @@
+/** Read-only instance inventories. Each needs an interactive One account login with a selected
+ * organization and project; the gateway admits nothing else on these products. */
+export function rigsModule(client) {
+    return { list: () => client.request('rigs_listRigs') };
+}
+export function panesModule(client) {
+    return { list: () => client.request('panes_listPanes') };
+}
+export function shellsModule(client) {
+    return { list: () => client.request('shells_listShells') };
+}