@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/hives-operations.d.ts

@@ -0,0 +1,337 @@
+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: {
+        consumer: {
+            get(project: string, queue: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerStatus>;
+            configure(project: string, queue: string, input: import("./hives-queue-consumer.js").HivesQueueConsumerConfig, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerBinding>;
+            remove(project: string, queue: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                success: true;
+                queueId: string;
+            }>;
+        };
+        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-queue-funding.js").HivesQueueSendOptions): Promise<import("./hives-queue-funding.js").HivesQueueOperation | {
+            message_id: string;
+        }>;
+        operations: {
+            get(project: string, id: string, operationId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-funding.js").HivesQueueOperation>;
+        };
+        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;
+        }>;
+    };
+    topics: {
+        list(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            data: import("./hives-topics.js").HivesTopic[];
+        }>;
+        get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopic>;
+        create(project: string, body: {
+            name: string;
+        }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopic>;
+        remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+            deleted: true;
+        }>;
+        subscriptions: {
+            list(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                data: import("./hives-topics.js").HivesTopicSubscription[];
+            }>;
+            add(project: string, id: string, queueId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopicSubscription>;
+            remove(project: string, id: string, subscriptionId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                deleted: true;
+            }>;
+        };
+        publish(project: string, id: string, body: import("./hives-topics.js").HivesTopicPublish, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopicPublication>;
+    };
+    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,41 @@
+import { hivesTopics } from './hives-topics.js';
+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),
+        topics: hivesTopics(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-queue-consumer.d.ts

@@ -0,0 +1,56 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+/** Every delivery setting must match the existing standard queue. */
+export interface HivesQueueConsumerConfig {
+    functionId: string;
+    queueName: string;
+    batchSize: 1;
+    maxConcurrent: 1;
+    visibilityTimeoutSecs: number;
+    maxRetries: number;
+    deadLetterQueue?: string | null;
+    autoAck: true;
+    enabled: boolean;
+}
+export interface HivesQueueConsumerBinding {
+    queueId: string;
+    projectId: string;
+    functionId: string;
+    enabled: boolean;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HivesQueueConsumerAttempt {
+    id: string;
+    functionId: string;
+    consumerRevision: number;
+    messageId: string;
+    receiveCount: number;
+    status: 'running' | 'succeeded' | 'failed' | 'unconfirmed';
+    leaseExpiresAt: string;
+    startedAt: string;
+    completedAt: string | null;
+    executionId: string | null;
+    guestStatus: number | null;
+}
+export interface HivesQueueConsumerStatus {
+    consumer: {
+        binding: HivesQueueConsumerBinding | null;
+        latestAttempt: HivesQueueConsumerAttempt | null;
+        exhaustedMessages: number;
+    };
+    /** An operator setting, not evidence that an invocation succeeded. */
+    runtimeEnabled: boolean;
+    batchSize: 1;
+    maxConcurrent: 1;
+    autoAck: true;
+}
+export declare function hivesQueueConsumer(client: GenesisClient): {
+    get(project: string, queue: string, options?: HivesResourceOptions): Promise<HivesQueueConsumerStatus>;
+    configure(project: string, queue: string, input: HivesQueueConsumerConfig, options?: HivesResourceOptions): Promise<HivesQueueConsumerBinding>;
+    remove(project: string, queue: string, options?: HivesResourceOptions): Promise<{
+        success: true;
+        queueId: string;
+    }>;
+};

package/dist/hives-queue-consumer.js

@@ -0,0 +1,95 @@
+import { GenesisError } from './errors.js';
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+const badResponse = () => new GenesisError({ status: 0, type: 'invalid_response',
+    message: 'Hives returned an invalid or mismatched queue-consumer response. Read saved state before another mutation.' });
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw badResponse();
+    return value;
+}
+function id(value) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
+        throw badResponse();
+    return value;
+}
+function integer(value, minimum) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum)
+        throw badResponse();
+    return value;
+}
+function date(value) {
+    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value)))
+        throw badResponse();
+    return value;
+}
+function binding(value, project, queue) {
+    const row = record(value);
+    if (row.queueId !== queue || row.projectId !== project || typeof row.enabled !== 'boolean')
+        throw badResponse();
+    return { queueId: queue, projectId: project, functionId: id(row.functionId), enabled: row.enabled,
+        revision: integer(row.revision, 1), createdAt: date(row.createdAt), updatedAt: date(row.updatedAt) };
+}
+function attempt(value) {
+    const row = record(value);
+    if (!['running', 'succeeded', 'failed', 'unconfirmed'].includes(row.status))
+        throw badResponse();
+    const confirmed = row.status === 'succeeded' || row.status === 'failed';
+    if (confirmed) {
+        if (typeof row.executionId !== 'string' || !/^exec_[a-f0-9]{32}$/.test(row.executionId)
+            || typeof row.guestStatus !== 'number' || !Number.isInteger(row.guestStatus)
+            || row.guestStatus < 200 || row.guestStatus > 599 || row.completedAt === null
+            || (row.status === 'succeeded') !== (row.guestStatus < 300))
+            throw badResponse();
+    }
+    else if (row.executionId !== null || row.guestStatus !== null || row.status === 'running' && row.completedAt !== null)
+        throw badResponse();
+    // History can belong to an earlier function/revision even after the binding is removed.
+    return { id: id(row.id), functionId: id(row.functionId), consumerRevision: integer(row.consumerRevision, 1),
+        messageId: id(row.messageId), receiveCount: integer(row.receiveCount, 1), status: row.status,
+        leaseExpiresAt: date(row.leaseExpiresAt), startedAt: date(row.startedAt),
+        completedAt: row.completedAt === null ? null : date(row.completedAt),
+        executionId: row.executionId, guestStatus: row.guestStatus };
+}
+function config(value) {
+    const allowed = ['functionId', 'queueName', 'batchSize', 'maxConcurrent', 'visibilityTimeoutSecs', 'maxRetries', 'deadLetterQueue', 'autoAck', 'enabled'];
+    if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !allowed.includes(key))
+        || value.batchSize !== 1 || value.maxConcurrent !== 1 || value.autoAck !== true || typeof value.enabled !== 'boolean'
+        || !Number.isInteger(value.visibilityTimeoutSecs) || value.visibilityTimeoutSecs < 75 || value.visibilityTimeoutSecs > 4_294_967_295
+        || !Number.isInteger(value.maxRetries) || value.maxRetries < 0 || value.maxRetries > 9)
+        throw resourceError(0);
+    hivesResourceId(value.functionId);
+    hivesResourceId(value.queueName);
+    if (value.deadLetterQueue != null)
+        hivesResourceId(value.deadLetterQueue);
+    return { functionId: value.functionId, queueName: value.queueName, batchSize: 1, maxConcurrent: 1,
+        visibilityTimeoutSecs: value.visibilityTimeoutSecs, maxRetries: value.maxRetries,
+        deadLetterQueue: value.deadLetterQueue ?? null, autoAck: true, enabled: value.enabled };
+}
+export function hivesQueueConsumer(client) {
+    const params = (project, queue) => ({ project_id: hivesResourceId(project), queue_id: hivesResourceId(queue) });
+    const call = (operation, input, options) => hivesResourceCall(client, operation, input, options, 'json', 64 * 1024, 20_000, 200);
+    return {
+        async get(project, queue, options) {
+            const row = record(await call('hives_get_native_queue_consumer', params(project, queue), options));
+            const status = record(row.consumer);
+            if (typeof row.runtimeEnabled !== 'boolean' || row.batchSize !== 1 || row.maxConcurrent !== 1 || row.autoAck !== true)
+                throw badResponse();
+            return { consumer: { binding: status.binding === null ? null : binding(status.binding, project, queue),
+                    latestAttempt: status.latestAttempt === null ? null : attempt(status.latestAttempt), exhaustedMessages: integer(status.exhaustedMessages, 0) },
+                runtimeEnabled: row.runtimeEnabled, batchSize: 1, maxConcurrent: 1, autoAck: true };
+        },
+        async configure(project, queue, input, options) {
+            const body = config(input);
+            const result = binding(await call('hives_configure_native_queue_consumer', { ...params(project, queue), body }, options), project, queue);
+            if (result.functionId !== body.functionId || result.enabled !== body.enabled)
+                throw badResponse();
+            return result;
+        },
+        async remove(project, queue, options) {
+            const result = record(await call('hives_remove_native_queue_consumer', params(project, queue), options));
+            if (result.success !== true || result.queueId !== queue)
+                throw badResponse();
+            return { success: true, queueId: queue };
+        },
+    };
+}

package/dist/hives-queue-funding.d.ts

@@ -0,0 +1,28 @@
+import { GenesisError } from './errors.js';
+export interface HivesQueueSendOptions {
+    signal?: AbortSignal;
+    idempotencyKey?: string;
+}
+export interface HivesQueueOperation {
+    object: 'queue_send_operation';
+    operation_id: string;
+    state: 'prepared' | 'reserve_unknown' | 'reserved' | 'dispatch_unknown' | 'dispatch_authorized' | 'commit_unknown' | 'settle_unknown' | 'settled' | 'denied' | 'released';
+    code: string;
+    message_id: string | null;
+    funding_source: 'sandbox_allowance' | null;
+    reservation_id: string | null;
+    native_meter: 'hives.queue_operations';
+    quantity_base: string | null;
+    upper_bound_quantity_base: string;
+    retry_send: false;
+}
+export declare const isHivesQueueFundingOperation: (id: string) => id is "hives_send_native_queue" | "hives_get_operation_native_queue";
+export declare function hivesQueueOperationId(value: unknown): string;
+export declare function hivesQueueSendHeaders(options: HivesQueueSendOptions): Record<string, string>;
+export declare function hivesQueueOperation(value: unknown, expected: unknown): HivesQueueOperation;
+export declare class HivesQueueOperationError extends GenesisError {
+    readonly operation: HivesQueueOperation;
+    constructor(status: number, operation: HivesQueueOperation);
+}
+/** Only a bounded typed receipt is retained from an error; never an echoed message body. */
+export declare function hivesQueueOperationError(response: Response, expected?: unknown): Promise<HivesQueueOperationError | undefined>;

package/dist/hives-queue-funding.js

@@ -0,0 +1,81 @@
+import { GenesisError } from './errors.js';
+export const isHivesQueueFundingOperation = (id) => id === 'hives_send_native_queue' || id === 'hives_get_operation_native_queue';
+export function hivesQueueOperationId(value) {
+    if (typeof value !== 'string' || !/^qop_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}$/.test(value))
+        throw new Error('Use the original queue operation ID. No send was retried.');
+    return value;
+}
+export function hivesQueueSendHeaders(options) {
+    if (options.idempotencyKey === undefined)
+        return {};
+    if (typeof options.idempotencyKey !== 'string' || !/^[ -~]{1,128}$/.test(options.idempotencyKey))
+        throw new Error('Use one persisted queue Idempotency-Key of 1–128 printable ASCII bytes.');
+    return { 'idempotency-key': options.idempotencyKey };
+}
+export function hivesQueueOperation(value, expected) {
+    const operation = hivesQueueOperationId(expected), r = value;
+    const keys = ['object', 'operation_id', 'state', 'code', 'message_id', 'funding_source', 'reservation_id', 'native_meter', 'quantity_base', 'upper_bound_quantity_base', 'retry_send'];
+    if (!r || typeof r !== 'object' || Array.isArray(r) || Object.keys(r).length !== keys.length || keys.some(k => !Object.hasOwn(r, k))
+        || r.object !== 'queue_send_operation' || r.operation_id !== operation || r.retry_send !== false || r.native_meter !== 'hives.queue_operations'
+        || !['prepared', 'reserve_unknown', 'reserved', 'dispatch_unknown', 'dispatch_authorized', 'commit_unknown', 'settle_unknown', 'settled', 'denied', 'released'].includes(r.state)
+        || typeof r.code !== 'string' || !/^[a-z_]{1,80}$/.test(r.code)
+        || r.funding_source !== null && r.funding_source !== 'sandbox_allowance'
+        || r.reservation_id !== null && !/^gfr_[A-Za-z0-9_.:@-]{1,124}$/.test(r.reservation_id)
+        || r.message_id !== null && !/^msg_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}$/.test(r.message_id)
+        || typeof r.upper_bound_quantity_base !== 'string' || !/^[1-5]$/.test(r.upper_bound_quantity_base)
+        || r.quantity_base !== null && (typeof r.quantity_base !== 'string' || !/^[1-5]$/.test(r.quantity_base) || Number(r.quantity_base) > Number(r.upper_bound_quantity_base))
+        || r.quantity_base !== null && (!r.message_id || !r.reservation_id || !r.funding_source)
+        || r.state === 'settled' && (!r.quantity_base || !r.message_id || !r.reservation_id || !r.funding_source)) {
+        throw new Error('Queue operation receipt is invalid or mismatched. Retain its original identity; no send was retried.');
+    }
+    return Object.fromEntries(keys.map(k => [k, r[k]]));
+}
+export class HivesQueueOperationError extends GenesisError {
+    operation;
+    constructor(status, operation) {
+        super({ status, type: 'hives_queue_operation', message: 'Read the original queue operation. Do not retry the send with a new key.', body: operation });
+        this.operation = operation;
+    }
+}
+/** Only a bounded typed receipt is retained from an error; never an echoed message body. */
+export async function hivesQueueOperationError(response, expected) {
+    const id = response.headers.get('x-hives-operation-id');
+    try {
+        hivesQueueOperationId(id);
+        if (expected !== undefined && id !== hivesQueueOperationId(expected))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.body || !response.headers.get('content-type')?.toLowerCase().includes('application/json'))
+        return undefined;
+    const reader = response.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 4096) {
+                await reader.cancel();
+                return undefined;
+            }
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(size);
+        let at = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, at);
+            at += chunk.length;
+        }
+        return new HivesQueueOperationError(response.status, hivesQueueOperation(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)), id));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}