@lifesi/genesis 0.1.1 → 0.1.2

package/dist/hives-operations.d.ts

@@ -0,0 +1,304 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
+export declare function hivesOperations(client: GenesisClient): {
+    cells: {
+        list(project: string, query?: {
+            page?: number;
+            per_page?: number;
+        }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucketList>;
+        get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucket>;
+        create(project: string, body: import("./hives-cells.js").HivesCreateBucket, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucket>;
+        remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            id: string;
+            success: boolean;
+            message: string;
+        }>;
+        reconcile(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            bucket: import("./hives-cells.js").HivesBucket;
+            outcome: string;
+        }>;
+        cors: {
+            get: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-cells.js").HivesCorsRule[]>;
+            set: (project: string, id: string, rules: import("./hives-cells.js").HivesCorsRule[], options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-cells.js").HivesCorsRule[]>;
+        };
+        objects: {
+            list(project: string, id: string, query?: {
+                prefix?: string;
+                delimiter?: string;
+                continuation_token?: string;
+                max_keys?: number;
+            }, 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").HivesResourceOptions & {
+                content_type?: string;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            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").HivesResourceOptions & {
+                content_type?: string;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            removeFlat: (project: string, id: string, key: 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>;
+    };
+    queues: {
+        list(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            data: import("./hives-queues.js").HivesQueue[];
+            engine_available: true;
+        }>;
+        get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        create(project: string, body: import("./hives-queues.js").HivesQueueCreate, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        configure(project: string, id: string, body: import("./hives-queues.js").HivesQueueConfig, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            deleted: true;
+        }>;
+        stats(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        consumers: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<never>;
+        pause(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        resume(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+        purge(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            purged: number;
+        }>;
+        send(project: string, id: string, body: import("./hives-queues.js").HivesQueueSend, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            message_id: string;
+        }>;
+        receive(project: string, id: string, body?: {
+            maxMessages?: number;
+            waitSeconds?: number;
+        }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            messages: import("./hives-queues.js").HivesQueueDelivery[];
+        }>;
+        ack: (project: string, id: string, message: string, receipt: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+            acknowledged: boolean;
+            released: boolean;
+        }>;
+        nack: (project: string, id: string, message: string, receipt: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+            acknowledged: boolean;
+            released: boolean;
+        }>;
+        deadLetters: (project: string, id: string, query?: {
+            limit?: number;
+            offset?: number;
+        }, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+            messages: import("./hives-queues.js").HivesDeadLetter[];
+        }>;
+        deadLetterStats: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-queues.js").HivesDeadLetterStats>;
+        replay(project: string, id: string, message: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            message_id: string;
+            replayed: 1;
+        }>;
+        deleteDeadLetter(project: string, id: string, message: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            deleted: true;
+        }>;
+        purgeDeadLetters(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            purged: number;
+        }>;
+    };
+    runtimes: {
+        list: (options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+            runtimes: import("./hives-runtimes.js").HivesRuntime[];
+        }>;
+        project: (project_id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+            runtimes: import("./hives-runtimes.js").HivesRuntime[];
+        }>;
+        get: (name: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-runtimes.js").HivesRuntime>;
+        select: (input: {
+            wasi: string;
+            runner: string;
+            artifact: string;
+        }, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-runtimes.js").HivesRuntimeSelection>;
+    };
+    settings: {
+        get: (project_id: string) => Promise<{
+            autoDeployEnabled: boolean;
+            buildCommand?: string | null;
+            defaultRegion: string;
+            installCommand?: string | null;
+            outputDirectory?: string | null;
+            previewDeploymentsEnabled: boolean;
+        } & {
+            capabilities: import("./index.js").components["schemas"]["Hives.ProjectSettingsCapabilities"];
+            effective: import("./index.js").components["schemas"]["Hives.EffectiveProjectSettings"];
+        }>;
+        update: (project_id: string, body: In<"hives_update_project_settings">["body"]) => Promise<{
+            autoDeployEnabled: boolean;
+            buildCommand?: string | null;
+            defaultRegion: string;
+            installCommand?: string | null;
+            outputDirectory?: string | null;
+            previewDeploymentsEnabled: boolean;
+        } & {
+            capabilities: import("./index.js").components["schemas"]["Hives.ProjectSettingsCapabilities"];
+            effective: import("./index.js").components["schemas"]["Hives.EffectiveProjectSettings"];
+        }>;
+    };
+    crons: {
+        list: (project_id: string, q?: Omit<In<"hives_list_crons">, "project_id">) => Promise<Record<string, never>>;
+        get: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+        create: (project_id: string, body: In<"hives_create_cron">["body"]) => Promise<Record<string, never>>;
+        update: (project_id: string, cron_id: string, body: In<"hives_update_cron">["body"]) => Promise<Record<string, never>>;
+        delete: (project_id: string, cron_id: string) => Promise<{
+            id: string;
+            message: string;
+            success: boolean;
+        }>;
+        pause: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+        resume: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+        /** Admission returns a persisted run ID; read history to learn its actual outcome. No retry. */
+        trigger: (project_id: string, cron_id: string) => Promise<unknown>;
+        runs: (project_id: string, cron_id: string, q?: Omit<In<"hives_get_cron_runs">, "project_id" | "cron_id">) => Promise<{
+            data: {
+                duration_ms?: number | null;
+                ended_at?: string | null;
+                error?: string | null;
+                id: string;
+                logs_url?: string | null;
+                started_at: string;
+                status: string;
+            }[];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+        }>;
+    };
+    metrics: {
+        project: (project_id: string, q?: Omit<In<"hives_get_project_metrics">, "project_id">) => Promise<{
+            active_deployments: number;
+            avg_api_http_duration_ms?: number | null;
+            avg_response_time_ms?: number | null;
+            cron_executions?: number | null;
+            data_transfer_bytes: number;
+            error_count: number;
+            error_rate?: number | null;
+            function_invocations: number;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            p95_response_time_ms?: number | null;
+            p99_response_time_ms?: number | null;
+            project_id: string;
+            storage_bytes?: number | null;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+            total_requests: number;
+            unique_visitors?: number | null;
+        }>;
+        dashboard: (project_id: string, q?: Omit<In<"hives_get_dashboard_metrics">, "project_id">) => Promise<{
+            activeDeployments: number;
+            avgApiHttpDurationMs?: number | null;
+            avgLatencyMs?: number | null;
+            deploymentsChange?: number | null;
+            errorRate?: number | null;
+            errorRateChange?: number | null;
+            errorTimeSeries: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            latencyChange?: number | null;
+            latencyTimeSeries: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observedRequestPayloadBytes: number;
+            observedResponsePayloadBytes: number;
+            requestsChange?: number | null;
+            requestsTimeSeries: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            totalRequests: number;
+        }>;
+        requests: (project_id: string, q?: Omit<In<"hives_get_request_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        latency: (project_id: string, q?: Omit<In<"hives_get_latency_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        errors: (project_id: string, q?: Omit<In<"hives_get_error_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        function: (project_id: string, function_id: string, q?: Omit<In<"hives_get_function_metrics">, "project_id" | "function_id">) => Promise<{
+            avg_api_http_duration_ms?: number | null;
+            avg_duration_ms?: number | null;
+            billed_gb_seconds?: number | null;
+            cold_starts?: number | null;
+            configured_memory_limit_mb: number;
+            failed_invocations: number;
+            function_id: string;
+            function_name: string;
+            memory_mb?: number | null;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            p50_duration_ms?: number | null;
+            p95_duration_ms?: number | null;
+            p99_duration_ms?: number | null;
+            success_rate?: number | null;
+            successful_invocations: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+            timeouts?: number | null;
+            total_invocations: number;
+        }>;
+        invocations: (project_id: string, function_id: string, q?: Omit<In<"hives_get_function_invocations_series">, "project_id" | "function_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        deployment: (project_id: string, deployment_id: string, q?: Omit<In<"hives_get_deployment_metrics">, "project_id" | "deployment_id">) => Promise<{
+            active_instances?: number | null;
+            avg_api_http_duration_ms?: number | null;
+            avg_cpu_percent?: number | null;
+            avg_memory_mb?: number | null;
+            avg_response_time_ms?: number | null;
+            deployment_id: string;
+            error_count: number;
+            error_rate?: number | null;
+            max_instances?: number | null;
+            min_instances?: number | null;
+            network_in_bytes?: number | null;
+            network_out_bytes?: number | null;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            p95_response_time_ms?: number | null;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+            total_requests: number;
+        }>;
+        resources: (project_id: string, q?: Omit<In<"hives_get_resource_usage">, "project_id">) => Promise<{
+            active_deployments: number;
+            avg_api_http_duration_ms?: number | null;
+            bandwidth_gb?: number | null;
+            build_minutes?: number | null;
+            compute_gb_seconds?: number | null;
+            custom_domains: number;
+            function_invocations: number;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            scheduled_jobs: number;
+            ssl_certificates: number;
+            storage_gb?: number | null;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        realtime: (project_id: string) => Promise<{
+            active_connections?: number | null;
+            avg_api_http_duration_ms?: number | null;
+            avg_response_time_ms?: number | null;
+            cpu_percent?: number | null;
+            error_rate?: number | null;
+            memory_percent?: number | null;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            requests_per_second: number;
+            updated_at: string;
+        }>;
+    };
+};

package/dist/hives-operations.js

@@ -0,0 +1,39 @@
+import { hivesCells } from './hives-cells.js';
+import { hivesQueues } from './hives-queues.js';
+import { hivesRuntimes } from './hives-runtimes.js';
+/** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
+export function hivesOperations(client) {
+    return {
+        cells: hivesCells(client),
+        queues: hivesQueues(client),
+        runtimes: hivesRuntimes(client),
+        settings: {
+            get: (project_id) => client.request('hives_get_project_settings', { project_id }),
+            update: (project_id, body) => client.request('hives_update_project_settings', { project_id, body }),
+        },
+        crons: {
+            list: (project_id, q = {}) => client.request('hives_list_crons', { ...q, project_id }),
+            get: (project_id, cron_id) => client.request('hives_get_cron', { project_id, cron_id }),
+            create: (project_id, body) => client.request('hives_create_cron', { project_id, body }),
+            update: (project_id, cron_id, body) => client.request('hives_update_cron', { project_id, cron_id, body }),
+            delete: (project_id, cron_id) => client.request('hives_delete_cron', { project_id, cron_id }),
+            pause: (project_id, cron_id) => client.request('hives_pause_cron', { project_id, cron_id }),
+            resume: (project_id, cron_id) => client.request('hives_resume_cron', { project_id, cron_id }),
+            /** Admission returns a persisted run ID; read history to learn its actual outcome. No retry. */
+            trigger: (project_id, cron_id) => client.request('hives_trigger_cron', { project_id, cron_id }),
+            runs: (project_id, cron_id, q = {}) => client.request('hives_get_cron_runs', { ...q, project_id, cron_id }),
+        },
+        metrics: {
+            project: (project_id, q = {}) => client.request('hives_get_project_metrics', { ...q, project_id }),
+            dashboard: (project_id, q = {}) => client.request('hives_get_dashboard_metrics', { ...q, project_id }),
+            requests: (project_id, q = {}) => client.request('hives_get_request_metrics', { ...q, project_id }),
+            latency: (project_id, q = {}) => client.request('hives_get_latency_metrics', { ...q, project_id }),
+            errors: (project_id, q = {}) => client.request('hives_get_error_metrics', { ...q, project_id }),
+            function: (project_id, function_id, q = {}) => client.request('hives_get_function_metrics', { ...q, project_id, function_id }),
+            invocations: (project_id, function_id, q = {}) => client.request('hives_get_function_invocations_series', { ...q, project_id, function_id }),
+            deployment: (project_id, deployment_id, q = {}) => client.request('hives_get_deployment_metrics', { ...q, project_id, deployment_id }),
+            resources: (project_id, q = {}) => client.request('hives_get_resource_usage', { ...q, project_id }),
+            realtime: (project_id) => client.request('hives_get_realtime_metrics', { project_id }),
+        },
+    };
+}

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