@lifesi/genesis 0.1.1 → 0.1.3

package/dist/hives-queues.d.ts

@@ -0,0 +1,121 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+export interface HivesQueueConfig {
+    retentionPeriod: number;
+    visibilityTimeout: number;
+    maxReceiveCount: number;
+    deadLetterQueueId?: string | null;
+}
+export interface HivesQueue extends HivesQueueConfig {
+    id: string;
+    projectId: string;
+    name: string;
+    type: 'standard' | 'dead_letter' | 'fifo';
+    status: 'active' | 'paused';
+    deliveryAvailable: boolean;
+    maxMessageSize: number;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    messagesProcessing: number;
+    delayedMessages: number;
+    retainedMessages: number;
+    retainedPayloadBytes: number;
+    consumerCount: null;
+    throughputPerSecond: null;
+    avgProcessingTimeMs: null;
+}
+export interface HivesQueueCreate {
+    name: string;
+    type?: 'standard' | 'dead_letter';
+    retentionPeriod?: number;
+    visibilityTimeout?: number;
+    maxReceiveCount?: number;
+    deadLetterQueueId?: string | null;
+}
+export interface HivesQueueSend {
+    body?: unknown;
+    body_base64?: string;
+    attributes?: Record<string, string>;
+}
+export interface HivesQueueDelivery {
+    id: string;
+    body_base64: string;
+    attributes: Record<string, string>;
+    receive_count: number;
+    receipt_handle: string;
+    lease_expires_at: string;
+    created_at: string;
+}
+export interface HivesDeadLetter {
+    id: string;
+    queue_id: string;
+    original_queue_id: string | null;
+    original_message_id: string | null;
+    body_base64: string;
+    attributes: Record<string, string>;
+    receive_count: number;
+    reason: string | null;
+    moved_at: string | null;
+}
+export interface HivesDeadLetterStats {
+    total_messages: number;
+    oldest_message_at: string | null;
+    newest_message_at: string | null;
+    average_receive_count: number | null;
+    retained_payload_bytes: number;
+}
+export declare function hivesQueueBody(encoded: string): Uint8Array;
+export declare function hivesQueues(client: GenesisClient): {
+    list(project: string, options?: HivesResourceOptions): Promise<{
+        data: HivesQueue[];
+        engine_available: true;
+    }>;
+    get(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    create(project: string, body: HivesQueueCreate, options?: HivesResourceOptions): Promise<HivesQueue>;
+    configure(project: string, id: string, body: HivesQueueConfig, options?: HivesResourceOptions): Promise<HivesQueue>;
+    remove(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        deleted: true;
+    }>;
+    stats(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    consumers: (project: string, id: string, options?: HivesResourceOptions) => Promise<never>;
+    pause(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    resume(project: string, id: string, options?: HivesResourceOptions): Promise<HivesQueue>;
+    purge(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        purged: number;
+    }>;
+    send(project: string, id: string, body: HivesQueueSend, options?: HivesResourceOptions): Promise<{
+        message_id: string;
+    }>;
+    receive(project: string, id: string, body?: {
+        maxMessages?: number;
+        waitSeconds?: number;
+    }, options?: HivesResourceOptions): Promise<{
+        messages: HivesQueueDelivery[];
+    }>;
+    ack: (project: string, id: string, message: string, receipt: string, options?: HivesResourceOptions) => Promise<{
+        acknowledged: boolean;
+        released: boolean;
+    }>;
+    nack: (project: string, id: string, message: string, receipt: string, options?: HivesResourceOptions) => Promise<{
+        acknowledged: boolean;
+        released: boolean;
+    }>;
+    deadLetters: (project: string, id: string, query?: {
+        limit?: number;
+        offset?: number;
+    }, options?: HivesResourceOptions) => Promise<{
+        messages: HivesDeadLetter[];
+    }>;
+    deadLetterStats: (project: string, id: string, options?: HivesResourceOptions) => Promise<HivesDeadLetterStats>;
+    replay(project: string, id: string, message: string, options?: HivesResourceOptions): Promise<{
+        message_id: string;
+        replayed: 1;
+    }>;
+    deleteDeadLetter(project: string, id: string, message: string, options?: HivesResourceOptions): Promise<{
+        deleted: true;
+    }>;
+    purgeDeadLetters(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        purged: number;
+    }>;
+};

package/dist/hives-queues.js

@@ -0,0 +1,106 @@
+import { HIVES_QUEUE_BYTES, hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+export function hivesQueueBody(encoded) {
+    if (typeof encoded !== 'string' || encoded.length > Math.ceil(HIVES_QUEUE_BYTES / 3) * 4 || encoded.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded))
+        throw resourceError(0);
+    try {
+        const bytes = atob(encoded);
+        if (btoa(bytes) !== encoded || bytes.length > HIVES_QUEUE_BYTES)
+            throw resourceError(0);
+        return Uint8Array.from(bytes, c => c.charCodeAt(0));
+    }
+    catch {
+        throw resourceError(0);
+    }
+}
+function config(body, required = false) {
+    const ranges = [{ key: 'retentionPeriod', min: 3600, max: 336 * 3600, divisor: 3600 }, { key: 'visibilityTimeout', min: 1, max: 43200 }, { key: 'maxReceiveCount', min: 1, max: 1000 }];
+    for (const r of ranges) {
+        const value = body[r.key];
+        if (value === undefined && !required)
+            continue;
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < r.min || value > r.max || r.divisor && value % r.divisor)
+            throw resourceError(0);
+    }
+    if (body.deadLetterQueueId != null)
+        hivesResourceId(body.deadLetterQueueId);
+}
+function queue(value, project, id) {
+    if (!value || value.projectId !== project || typeof value.id !== 'string' || id !== undefined && value.id !== id || !['standard', 'dead_letter', 'fifo'].includes(value.type) || !['active', 'paused'].includes(value.status) || typeof value.deliveryAvailable !== 'boolean' || value.type === 'fifo' && value.deliveryAvailable !== false)
+        throw resourceError(0);
+    const counts = [value.messageCount, value.messagesProcessing, value.delayedMessages, value.retainedMessages, value.retainedPayloadBytes];
+    if (counts.some(v => !Number.isSafeInteger(v) || v < 0) || value.consumerCount !== null || value.throughputPerSecond !== null || value.avgProcessingTimeMs !== null)
+        throw resourceError(0);
+    return Object.fromEntries(['id', 'projectId', 'name', 'type', 'status', 'deliveryAvailable', 'retentionPeriod', 'visibilityTimeout', 'maxReceiveCount', 'deadLetterQueueId', 'maxMessageSize', 'createdAt', 'updatedAt', 'messageCount', 'messagesProcessing', 'delayedMessages', 'retainedMessages', 'retainedPayloadBytes', 'consumerCount', 'throughputPerSecond', 'avgProcessingTimeMs'].map(k => [k, value[k]]));
+}
+function send(body) {
+    if (!body || typeof body !== 'object' || Object.keys(body).some(k => !['body', 'body_base64', 'attributes'].includes(k)) || (body.body != null) === (body.body_base64 != null))
+        throw resourceError(0);
+    if (body.body_base64 != null)
+        hivesQueueBody(body.body_base64);
+    else {
+        let value;
+        try {
+            value = typeof body.body === 'string' ? body.body : JSON.stringify(body.body);
+        }
+        catch {
+            throw resourceError(0);
+        }
+        if (value === undefined || new TextEncoder().encode(value).length > HIVES_QUEUE_BYTES)
+            throw resourceError(0);
+    }
+    if (body.attributes !== undefined) {
+        if (!body.attributes || typeof body.attributes !== 'object' || Array.isArray(body.attributes) || Object.keys(body.attributes).length > 64 || Object.entries(body.attributes).some(([k, v]) => !k || new TextEncoder().encode(k).length > 128 || k.startsWith('buzz.') || typeof v !== 'string') || new TextEncoder().encode(JSON.stringify(body.attributes)).length > 8192)
+            throw resourceError(0);
+    }
+}
+export function hivesQueues(client) {
+    const ids = (project_id, queue_id) => ({ project_id: hivesResourceId(project_id), ...(queue_id === undefined ? {} : { queue_id: hivesResourceId(queue_id) }) });
+    const call = (operation, input, options, limit = 2 * 1024 * 1024) => hivesResourceCall(client, operation, input, options, 'json', limit, 20_000);
+    const ack = async (project, id, message, receipt, release, options) => {
+        if (typeof receipt !== 'string' || !/^rh_[a-f0-9]{32}$/.test(receipt))
+            throw resourceError(0);
+        const result = await call(release ? 'hives_nack_native_queue' : 'hives_ack_native_queue', { ...ids(project, id), message_id: hivesResourceId(message), body: { receiptHandle: receipt } }, options);
+        if (!result || result.acknowledged !== !release || result.released !== release)
+            throw resourceError(0);
+        return result;
+    };
+    return {
+        async list(project, options) { const result = await call('hives_list_native_queue', ids(project), options); if (!result || !Array.isArray(result.data) || result.engine_available !== true)
+            throw resourceError(0); return { ...result, data: result.data.map(row => queue(row, project)) }; },
+        async get(project, id, options) { return queue(await call('hives_inspect_native_queue', ids(project, id), options), project, id); },
+        async create(project, body, options) { if (!body || !/^[A-Za-z0-9_-]{1,128}$/.test(body.name) || body.type !== undefined && !['standard', 'dead_letter'].includes(body.type) || Object.keys(body).some(k => !['name', 'type', 'retentionPeriod', 'visibilityTimeout', 'maxReceiveCount', 'deadLetterQueueId'].includes(k)))
+            throw resourceError(0); config(body); return queue(await call('hives_create_native_queue', { ...ids(project), body }, options), project); },
+        async configure(project, id, body, options) { if (!body || Object.keys(body).some(k => !['retentionPeriod', 'visibilityTimeout', 'maxReceiveCount', 'deadLetterQueueId'].includes(k)))
+            throw resourceError(0); config(body, true); return queue(await call('hives_configure_native_queue', { ...ids(project, id), body }, options), project, id); },
+        async remove(project, id, options) { const result = await call('hives_delete_native_queue', ids(project, id), options); if (result?.deleted !== true)
+            throw resourceError(0); return result; },
+        async stats(project, id, options) { return queue(await call('hives_stats_native_queue', ids(project, id), options), project, id); },
+        consumers: (project, id, options) => call('hives_consumers_native_queue', ids(project, id), options),
+        async pause(project, id, options) { return queue(await call('hives_pause_native_queue', ids(project, id), options), project, id); },
+        async resume(project, id, options) { return queue(await call('hives_resume_native_queue', ids(project, id), options), project, id); },
+        async purge(project, id, options) { const result = await call('hives_purge_native_queue', ids(project, id), options); if (!Number.isSafeInteger(result?.purged) || result.purged < 0)
+            throw resourceError(0); return result; },
+        async send(project, id, body, options) { send(body); const result = await call('hives_send_native_queue', { ...ids(project, id), body }, options); hivesResourceId(result?.message_id); return result; },
+        async receive(project, id, body = {}, options) { if (Object.keys(body).some(k => !['maxMessages', 'waitSeconds'].includes(k)) || body.maxMessages !== undefined && (!Number.isInteger(body.maxMessages) || body.maxMessages < 1 || body.maxMessages > 10) || body.waitSeconds !== undefined && (!Number.isInteger(body.waitSeconds) || body.waitSeconds < 0 || body.waitSeconds > 10))
+            throw resourceError(0); const result = await call('hives_receive_native_queue', { ...ids(project, id), body }, options, 4 * 1024 * 1024); if (!result || !Array.isArray(result.messages) || result.messages.length > (body.maxMessages ?? 1))
+            throw resourceError(0); for (const row of result.messages) {
+            hivesResourceId(row.id);
+            hivesQueueBody(row.body_base64);
+            if (!/^rh_[a-f0-9]{32}$/.test(row.receipt_handle))
+                throw resourceError(0);
+        } return result; },
+        ack: (project, id, message, receipt, options) => ack(project, id, message, receipt, false, options),
+        nack: (project, id, message, receipt, options) => ack(project, id, message, receipt, true, options),
+        deadLetters: async (project, id, query = {}, options) => { if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 10) || query.offset !== undefined && (!Number.isInteger(query.offset) || query.offset < 0 || query.offset > 8192))
+            throw resourceError(0); const result = await call('hives_dead_letters_native_queue', { ...query, ...ids(project, id) }, options, 4 * 1024 * 1024); if (!result || !Array.isArray(result.messages) || result.messages.length > (query.limit ?? 10))
+            throw resourceError(0); for (const row of result.messages)
+            hivesQueueBody(row.body_base64); return result; },
+        deadLetterStats: (project, id, options) => call('hives_dlq_stats_native_queue', ids(project, id), options),
+        async replay(project, id, message, options) { const result = await call('hives_replay_native_queue', { ...ids(project, id), body: { message_id: hivesResourceId(message) } }, options); if (result?.replayed !== 1)
+            throw resourceError(0); hivesResourceId(result.message_id); return result; },
+        async deleteDeadLetter(project, id, message, options) { const result = await call('hives_delete_dlq_native_queue', { ...ids(project, id), message_id: hivesResourceId(message) }, options); if (result?.deleted !== true)
+            throw resourceError(0); return result; },
+        async purgeDeadLetters(project, id, options) { const result = await call('hives_purge_dlq_native_queue', ids(project, id), options); if (!Number.isSafeInteger(result?.purged) || result.purged < 0)
+            throw resourceError(0); return result; },
+    };
+}

package/dist/hives-resources-transport.d.ts

@@ -0,0 +1,18 @@
+import type { GenesisClient } from './client.js';
+import { GenesisError } from './errors.js';
+export declare const HIVES_OBJECT_BYTES: number;
+export declare const HIVES_QUEUE_BYTES: number;
+export declare const HIVES_RESOURCE_JSON_BYTES: number;
+export interface HivesResourceOptions {
+    signal?: AbortSignal;
+}
+export declare function hivesResourceId(value: string): string;
+export declare function resourceError(status: number, id?: string): GenesisError;
+export declare const isHivesResourceOperation: (id: string) => boolean;
+export declare const isHivesObjectUpload: (id: string) => id is "hives_upload_object_by_key" | "hives_upload_object";
+/** Shared-client hook proposal: snapshot only the two real raw Cells upload operations. */
+export declare function hivesObjectBody(value: unknown): Promise<ArrayBuffer>;
+export declare function hivesContentType(value?: string): string;
+export declare function hivesResourceBytes(response: Response, limit: number, signal?: AbortSignal): Promise<Uint8Array>;
+/** Whole operation budget includes credential/fetch and incremental body read. No retries or redirects. */
+export declare function hivesResourceCall<T>(client: GenesisClient, id: string, input: Record<string, unknown>, options?: HivesResourceOptions, mode?: 'json' | 'empty' | 'binary', limit?: number, budget?: number): Promise<T>;

package/dist/hives-resources-transport.js

@@ -0,0 +1,165 @@
+import { GenesisError } from './errors.js';
+export const HIVES_OBJECT_BYTES = 10 * 1024 * 1024;
+export const HIVES_QUEUE_BYTES = 256 * 1024;
+export const HIVES_RESOURCE_JSON_BYTES = 2 * 1024 * 1024;
+export function hivesResourceId(value) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
+        throw resourceError(0);
+    return value;
+}
+export function resourceError(status, id) {
+    return new GenesisError({ status, type: status ? `http_${status}` : 'invalid_request', operationId: id,
+        message: status === 404 ? 'Hives resource not found in the authenticated organization and project.'
+            : status === 409 ? 'Hives resource state conflicted. Read persisted state before another mutation.'
+                : status === 503 ? 'Hives outcome is unavailable. Read persisted state or reconcile before another mutation.'
+                    : 'Hives resource request failed. Check the request and persisted state; no automatic retry was made.' });
+}
+export const isHivesResourceOperation = (id) => /^(?:hives_marketplace_(?:categories|featured|installed|get_installation|uninstall|reconcile|list_packages|publish|get_package|install|update|list_versions)|hives_.*_native_queue|hives_(?:(?:list_volumes|create_volume|get_volume|delete_volume|mount_volume|unmount_volume)|list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key)?|delete_object(?:_by_key)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
+export const isHivesObjectUpload = (id) => id === 'hives_upload_object_by_key' || id === 'hives_upload_object';
+/** Shared-client hook proposal: snapshot only the two real raw Cells upload operations. */
+export async function hivesObjectBody(value) {
+    let bytes;
+    if (value instanceof Blob) {
+        if (value.size > HIVES_OBJECT_BYTES)
+            throw resourceError(0);
+        bytes = new Uint8Array(await value.arrayBuffer());
+    }
+    else if (value instanceof ArrayBuffer)
+        bytes = new Uint8Array(value);
+    else if (ArrayBuffer.isView(value))
+        bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    else
+        throw resourceError(0);
+    if (bytes.byteLength > HIVES_OBJECT_BYTES)
+        throw resourceError(0);
+    return Uint8Array.from(bytes).buffer;
+}
+export function hivesContentType(value = 'application/octet-stream') {
+    if (typeof value !== 'string' || !value.length || new TextEncoder().encode(value).length > 512 || /[\u0000-\u001f\u007f]/.test(value))
+        throw resourceError(0);
+    return value;
+}
+export async function hivesResourceBytes(response, limit, signal) {
+    const chunks = [];
+    let length = 0;
+    const reader = response.body?.getReader();
+    if (!reader)
+        return new Uint8Array();
+    const cancel = () => { void reader.cancel().catch(() => { }); };
+    signal?.addEventListener('abort', cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    try {
+        for (;;) {
+            const next = await reader.read();
+            if (signal?.aborted)
+                throw resourceError(0);
+            if (next.done)
+                break;
+            length += next.value.byteLength;
+            if (length > limit) {
+                await reader.cancel();
+                throw resourceError(0);
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        signal?.removeEventListener('abort', cancel);
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const part of chunks) {
+        bytes.set(part, offset);
+        offset += part.byteLength;
+    }
+    return bytes;
+}
+/** Whole operation budget includes credential/fetch and incremental body read. No retries or redirects. */
+export async function hivesResourceCall(client, id, input, options = {}, mode = 'json', limit = HIVES_RESOURCE_JSON_BYTES, budget = 20_000) {
+    let snapshot;
+    try {
+        if (input.body instanceof ArrayBuffer)
+            snapshot = { ...input, body: input.body.slice(0) };
+        else {
+            const value = JSON.stringify(input);
+            if (new TextEncoder().encode(value).length > 512 * 1024)
+                throw resourceError(0);
+            snapshot = JSON.parse(value);
+        }
+    }
+    catch {
+        throw resourceError(0, id);
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    let rejectAbort = () => { };
+    const failure = new Promise((_, reject) => { rejectAbort = reject; });
+    void failure.catch(() => { });
+    const aborted = () => rejectAbort(resourceError(0, id));
+    controller.signal.addEventListener('abort', aborted, { once: true });
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const timer = setTimeout(abort, budget);
+    if (typeof timer === 'object' && 'unref' in timer)
+        timer.unref();
+    let response;
+    let completed = false;
+    const operation = (async () => {
+        if (options.signal?.aborted)
+            abort();
+        if (controller.signal.aborted)
+            throw resourceError(0, id);
+        response = await client.raw(id, snapshot, { signal: controller.signal });
+        if (controller.signal.aborted) {
+            await response.body?.cancel();
+            throw resourceError(0, id);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            await response.body?.cancel();
+            throw resourceError(response.status, id);
+        }
+        if (mode === 'empty' && ![200, 204].includes(response.status))
+            throw resourceError(0, id);
+        const bytes = await hivesResourceBytes(response, mode === 'empty' ? 0 : limit, controller.signal);
+        if (controller.signal.aborted)
+            throw resourceError(0, id);
+        if (mode === 'empty')
+            return undefined;
+        if (mode === 'binary') {
+            if (response.status !== 200)
+                throw resourceError(0, id);
+            const headers = new Headers({ 'content-type': hivesContentType(response.headers.get('content-type') ?? undefined), 'cache-control': 'no-store', 'content-disposition': 'attachment' });
+            return new Response(Uint8Array.from(bytes).buffer, { status: 200, headers });
+        }
+        if (!response.headers.get('content-type')?.toLowerCase().includes('application/json'))
+            throw resourceError(0, id);
+        try {
+            return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw resourceError(0, id);
+        }
+    })();
+    void operation.then(() => { if (controller.signal.aborted)
+        void response?.body?.cancel().catch(() => { }); }, () => { });
+    try {
+        const result = await Promise.race([operation, failure]);
+        completed = true;
+        return result;
+    }
+    catch (error) {
+        if (error instanceof GenesisError)
+            throw resourceError(error.status, id);
+        throw resourceError(0, id);
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', abort);
+        controller.signal.removeEventListener('abort', aborted);
+        if (!completed) {
+            controller.abort();
+            void response?.body?.cancel().catch(() => { });
+        }
+    }
+}

package/dist/hives-runtimes.d.ts

@@ -0,0 +1,34 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+export interface HivesRuntime {
+    name: string;
+    version: string;
+    wasiVersions: string[];
+    runners: string[];
+    artifactKinds: string[];
+    compiledFeatures: string[];
+    capabilityScope: 'compiled_serving_implementation';
+    features: string[];
+    useCases: string[];
+}
+export interface HivesRuntimeSelection {
+    selected: string;
+    reason: string;
+    wasi: string;
+    runner: string;
+    artifact: string;
+}
+export declare function hivesRuntimes(client: GenesisClient): {
+    list: (options?: HivesResourceOptions) => Promise<{
+        runtimes: HivesRuntime[];
+    }>;
+    project: (project_id: string, options?: HivesResourceOptions) => Promise<{
+        runtimes: HivesRuntime[];
+    }>;
+    get: (name: string, options?: HivesResourceOptions) => Promise<HivesRuntime>;
+    select: (input: {
+        wasi: string;
+        runner: string;
+        artifact: string;
+    }, options?: HivesResourceOptions) => Promise<HivesRuntimeSelection>;
+};

package/dist/hives-runtimes.js

@@ -0,0 +1,32 @@
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+function runtime(value) {
+    if (!value || typeof value !== 'object')
+        throw resourceError(0);
+    const row = value;
+    if (typeof row.name !== 'string' || typeof row.version !== 'string' || row.capabilityScope !== 'compiled_serving_implementation'
+        || ['wasiVersions', 'runners', 'artifactKinds', 'compiledFeatures', 'features', 'useCases'].some(k => !Array.isArray(row[k]) || !row[k].every(v => typeof v === 'string'))
+        || !row.wasiVersions.length || !row.runners.length || !row.artifactKinds.length)
+        throw resourceError(0);
+    return { name: row.name, version: row.version, wasiVersions: [...row.wasiVersions], runners: [...row.runners], artifactKinds: [...row.artifactKinds], compiledFeatures: [...row.compiledFeatures], capabilityScope: row.capabilityScope, features: [...row.features], useCases: [...row.useCases] };
+}
+export function hivesRuntimes(client) {
+    const list = async (id, input, options) => {
+        const result = await hivesResourceCall(client, id, input, options);
+        if (!result || !Array.isArray(result.runtimes))
+            throw resourceError(0);
+        return { runtimes: result.runtimes.map(runtime) };
+    };
+    return {
+        list: (options) => list('hives_list_runtimes', {}, options),
+        project: (project_id, options) => list('hives_list_project_runtimes', { project_id: hivesResourceId(project_id) }, options),
+        get: async (name, options) => runtime(await hivesResourceCall(client, 'hives_get_runtime', { name: hivesResourceId(name) }, options)),
+        select: async (input, options) => {
+            if (Object.keys(input).some(k => !['wasi', 'runner', 'artifact'].includes(k)) || Object.values(input).some(v => typeof v !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v)))
+                throw resourceError(0);
+            const result = await hivesResourceCall(client, 'hives_select_runtime', { ...input }, options);
+            if (!result || typeof result.selected !== 'string' || typeof result.reason !== 'string' || result.wasi !== input.wasi || result.runner !== input.runner || result.artifact !== input.artifact)
+                throw resourceError(0);
+            return result;
+        },
+    };
+}

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 {};