@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/hives-marketplace.d.ts

@@ -0,0 +1,128 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+export interface HivesMarketplacePackage {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    author_name: string;
+    visibility: 'public' | 'private' | 'unlisted';
+    categories: string[];
+    keywords: string[];
+    license: string;
+    installs: number;
+    stars: number;
+    verified: boolean;
+    featured: boolean;
+    free: boolean;
+    latest_version: string;
+    version_count: number;
+    owned: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export interface HivesMarketplaceVersion {
+    id: string;
+    package_id: string;
+    version: string;
+    module_hash: string;
+    size_bytes: number;
+    readme: string;
+    changelog: string;
+    required_env: string[];
+    downloads: number;
+    deprecated: boolean;
+    published_at: string;
+}
+export interface HivesMarketplaceInstallation {
+    id: string;
+    package_id: string;
+    slug: string;
+    name: string;
+    project_id: string;
+    version: string | null;
+    deployment_id: string | null;
+    deployment_status: string | null;
+    pending_version: string | null;
+    pending_deployment_id: string | null;
+    pending_deployment_status: string | null;
+    operation: 'install' | 'update' | 'cleanup' | 'uninstall' | null;
+    status: 'active' | 'updating' | 'failed' | 'uninstalled';
+    latest_version: string | null;
+    installed_at: string;
+}
+export interface HivesMarketplaceCategory {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    icon_url: string | null;
+    package_count: number;
+    sort_order: number;
+}
+export interface HivesMarketplacePage<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        page_size: number;
+        total: number;
+        total_pages: number;
+        has_next: boolean;
+        has_prev: boolean;
+    };
+}
+export interface HivesMarketplacePublish {
+    slug: string;
+    name: string;
+    module_hash: string;
+    version: string;
+    description?: string;
+    visibility?: HivesMarketplacePackage['visibility'];
+    categories?: string[];
+    keywords?: string[];
+    readme?: string;
+    changelog?: string;
+    required_env?: string[];
+    license?: string;
+}
+export interface HivesMarketplaceInstall {
+    version?: string | null;
+    env_overrides?: Record<string, string>;
+}
+export interface HivesMarketplaceSearch {
+    q?: string | null;
+    category?: string | null;
+    free_only?: boolean;
+    verified_only?: boolean;
+    sort?: 'name' | 'installs' | 'stars' | 'created' | 'updated';
+    order?: 'asc' | 'desc';
+    page?: number;
+    page_size?: number;
+}
+export type HivesMarketplaceDetail = HivesMarketplacePackage & {
+    versions: HivesMarketplaceVersion[];
+};
+/** Native Marketplace reuses verified project ownership and persisted deployment lifecycle.
+ * Writes are sent once. Read/reconcile saved state after an uncertain acknowledgement. */
+export declare function hivesMarketplace(client: GenesisClient): {
+    list(project: string, query?: HivesMarketplaceSearch, options?: HivesResourceOptions): Promise<HivesMarketplacePage<HivesMarketplacePackage>>;
+    get(project: string, packageSlug: string, query?: {
+        version?: string | null;
+    }, options?: HivesResourceOptions): Promise<HivesMarketplaceDetail>;
+    versions(project: string, packageSlug: string, query?: {
+        page?: number;
+        page_size?: number;
+    }, options?: HivesResourceOptions): Promise<HivesMarketplacePage<HivesMarketplaceVersion>>;
+    featured(project: string, options?: HivesResourceOptions): Promise<HivesMarketplacePage<HivesMarketplacePackage>>;
+    categories(project: string, options?: HivesResourceOptions): Promise<HivesMarketplaceCategory[]>;
+    publish(project: string, input: HivesMarketplacePublish, options?: HivesResourceOptions): Promise<HivesMarketplaceDetail>;
+    install(project: string, packageSlug: string, input?: HivesMarketplaceInstall, options?: HivesResourceOptions): Promise<HivesMarketplaceInstallation>;
+    update(project: string, packageSlug: string, input?: HivesMarketplaceInstall, options?: HivesResourceOptions): Promise<HivesMarketplaceInstallation>;
+    installed(project: string, query?: {
+        page?: number;
+        page_size?: number;
+    }, options?: HivesResourceOptions): Promise<HivesMarketplacePage<HivesMarketplaceInstallation>>;
+    getInstallation(project: string, id: string, options?: HivesResourceOptions): Promise<HivesMarketplaceInstallation>;
+    reconcile(project: string, id: string, options?: HivesResourceOptions): Promise<HivesMarketplaceInstallation>;
+    uninstall(project: string, id: string, options?: HivesResourceOptions): Promise<HivesMarketplaceInstallation>;
+};

package/dist/hives-marketplace.js

@@ -0,0 +1,187 @@
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+function invalid() { throw resourceError(0); }
+function record(value) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    invalid(); return value; }
+function keys(value, allowed) { if (Object.keys(value).some(key => !allowed.includes(key)))
+    invalid(); }
+function text(value, max) { if (typeof value !== 'string' || new TextEncoder().encode(value).length > max)
+    invalid(); return value; }
+function uuid(value) { const result = text(value, 36); if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(result))
+    invalid(); return result.toLowerCase(); }
+function slug(value) { const result = text(value, 64); if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(result))
+    invalid(); return result; }
+function semver(value, maxCore = 18446744073709551615n) {
+    const result = text(value, 64);
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(result);
+    if (!match || match.slice(1, 4).some(part => BigInt(part) > maxCore)
+        || match[4]?.split('.').some(part => /^\d+$/.test(part) && part.length > 1 && part.startsWith('0')))
+        invalid();
+    return result;
+}
+function count(value, min = 0, max = Number.MAX_SAFE_INTEGER) { if (!Number.isSafeInteger(value) || value < min || value > max)
+    invalid(); return value; }
+function bool(value) { if (typeof value !== 'boolean')
+    invalid(); return value; }
+function strings(value, limit, max) { if (!Array.isArray(value) || value.length > limit)
+    invalid(); return value.map(item => text(item, max)); }
+function date(value) { const result = text(value, 64); if (!Number.isFinite(Date.parse(result)))
+    invalid(); return result; }
+function nullable(value, parse) { return value === null ? null : parse(value); }
+function deployment(value) { const id = text(value, 64); if (!/^dpl_[A-Za-z0-9_-]+$/.test(id))
+    invalid(); return id; }
+function packageRow(value) {
+    const r = record(value);
+    if (!['public', 'private', 'unlisted'].includes(String(r.visibility)) || r.visibility === 'private' && r.owned !== true)
+        invalid();
+    return { id: uuid(r.id), slug: slug(r.slug), name: text(r.name, 128), description: text(r.description, 500), author_name: text(r.author_name, 1000),
+        visibility: r.visibility, categories: strings(r.categories, 5, 64), keywords: strings(r.keywords, 20, 64), license: text(r.license, 64),
+        installs: count(r.installs), stars: count(r.stars), verified: bool(r.verified), featured: bool(r.featured), free: bool(r.free),
+        latest_version: semver(r.latest_version), version_count: count(r.version_count, 1), owned: bool(r.owned), created_at: date(r.created_at), updated_at: date(r.updated_at) };
+}
+function versionRow(value, expectedPackage) {
+    const r = record(value);
+    const packageId = uuid(r.package_id);
+    const hash = text(r.module_hash, 64);
+    if (expectedPackage && packageId !== expectedPackage || !/^[a-f0-9]{64}$/.test(hash))
+        invalid();
+    return { id: uuid(r.id), package_id: packageId, version: semver(r.version), module_hash: hash, size_bytes: count(r.size_bytes, 1, 10 * 1024 * 1024),
+        readme: text(r.readme, 50_000), changelog: text(r.changelog, 2000), required_env: strings(r.required_env, 50, 128), downloads: count(r.downloads), deprecated: bool(r.deprecated), published_at: date(r.published_at) };
+}
+function installationRow(value, project, expectedId) {
+    const r = record(value);
+    if (r.project_id !== project || expectedId && uuid(r.id) !== uuid(expectedId) || !['active', 'updating', 'failed', 'uninstalled'].includes(String(r.status))
+        || !(r.operation === null || ['install', 'update', 'cleanup', 'uninstall'].includes(String(r.operation))))
+        invalid();
+    const result = { id: uuid(r.id), package_id: uuid(r.package_id), slug: slug(r.slug), name: text(r.name, 128), project_id: project,
+        version: nullable(r.version, semver), deployment_id: nullable(r.deployment_id, deployment), deployment_status: nullable(r.deployment_status, v => text(v, 32)),
+        pending_version: nullable(r.pending_version, semver), pending_deployment_id: nullable(r.pending_deployment_id, deployment), pending_deployment_status: nullable(r.pending_deployment_status, v => text(v, 32)),
+        operation: r.operation, status: r.status,
+        latest_version: nullable(r.latest_version, semver), installed_at: date(r.installed_at) };
+    if (result.status === 'uninstalled' && (result.operation || result.deployment_id || result.pending_deployment_id))
+        invalid();
+    return result;
+}
+function page(value, pageNumber, pageSize, parse) {
+    const r = record(value);
+    const p = record(r.pagination);
+    const total = count(p.total);
+    const pages = Math.ceil(total / pageSize);
+    if (p.page !== pageNumber || p.page_size !== pageSize || p.total_pages !== pages || p.has_next !== (pageNumber < pages) || p.has_prev !== (pageNumber > 1)
+        || !Array.isArray(r.data) || r.data.length > pageSize)
+        invalid();
+    const data = r.data.map(parse);
+    if (new Set(data.map(row => row.id)).size !== data.length)
+        invalid();
+    return { data, pagination: { page: pageNumber, page_size: pageSize, total, total_pages: pages, has_next: pageNumber < pages, has_prev: pageNumber > 1 } };
+}
+function details(value, expectedSlug, exactVersion) {
+    const r = record(value);
+    const pkg = packageRow(r);
+    if (pkg.slug !== expectedSlug || !Array.isArray(r.versions) || r.versions.length > 5 || r.versions.length === 0)
+        invalid();
+    const versions = r.versions.map(row => versionRow(row, pkg.id));
+    if (new Set(versions.map(row => row.id)).size !== versions.length || exactVersion && versions.some(row => row.version !== exactVersion))
+        invalid();
+    return { ...pkg, versions };
+}
+function pagination(query, max) {
+    keys(record(query), ['page', 'page_size']);
+    return { page: count(query.page ?? 1, 1, 100_000), page_size: count(query.page_size ?? max, 1, max) };
+}
+function installInput(input) {
+    const r = record(input);
+    keys(r, ['version', 'env_overrides']);
+    const env = record(r.env_overrides ?? {});
+    if (Object.keys(env).length > 50)
+        invalid();
+    const entries = Object.entries(env).map(([key, value]) => [text(key, 128), text(value, 4096)]);
+    return { ...(r.version == null ? {} : { version: semver(r.version) }), env_overrides: Object.fromEntries(entries) };
+}
+function publishInput(input) {
+    const r = record(input);
+    keys(r, ['slug', 'name', 'module_hash', 'version', 'description', 'visibility', 'categories', 'keywords', 'readme', 'changelog', 'required_env', 'license']);
+    const name = text(r.name, 128);
+    const hash = text(r.module_hash, 64);
+    const visibility = r.visibility ?? 'public';
+    if (!name.trim() || !/^[a-f0-9]{64}$/.test(hash) || !['public', 'private', 'unlisted'].includes(String(visibility)))
+        invalid();
+    const required = strings(r.required_env ?? [], 50, 128);
+    if (new Set(required).size !== required.length || required.some(key => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)))
+        invalid();
+    return { slug: slug(r.slug), name, module_hash: hash, version: semver(r.version, 2147483647n), description: text(r.description ?? '', 500),
+        visibility: visibility, categories: strings(r.categories ?? [], 5, 64), keywords: strings(r.keywords ?? [], 20, 64),
+        readme: text(r.readme ?? '', 50_000), changelog: text(r.changelog ?? '', 2000), required_env: required, license: text(r.license ?? '', 64) };
+}
+/** Native Marketplace reuses verified project ownership and persisted deployment lifecycle.
+ * Writes are sent once. Read/reconcile saved state after an uncertain acknowledgement. */
+export function hivesMarketplace(client) {
+    const projectInput = (project) => ({ project_id: hivesResourceId(project) });
+    const call = (operation, input, options) => hivesResourceCall(client, `hives_marketplace_${operation}`, input, options);
+    const mutate = async (operation, project, packageSlug, input, options) => {
+        const body = installInput(input);
+        const result = installationRow(await call(operation, { ...projectInput(project), slug: slug(packageSlug), body }, options), project);
+        if (result.slug !== packageSlug || result.status === 'uninstalled' || body.version && result.version !== body.version && result.pending_version !== body.version)
+            invalid();
+        return result;
+    };
+    return {
+        async list(project, query = {}, options) {
+            keys(record(query), ['q', 'category', 'free_only', 'verified_only', 'sort', 'order', 'page', 'page_size']);
+            const p = { page: count(query.page ?? 1, 1, 100_000), page_size: count(query.page_size ?? 20, 1, 100) };
+            const sort = query.sort ?? 'installs';
+            const order = query.order ?? 'desc';
+            if (!['name', 'installs', 'stars', 'created', 'updated'].includes(sort) || !['asc', 'desc'].includes(order))
+                invalid();
+            const input = { ...projectInput(project), ...p, sort, order, free_only: bool(query.free_only ?? false), verified_only: bool(query.verified_only ?? false),
+                ...(query.q == null ? {} : { q: text(query.q, 200) }), ...(query.category == null ? {} : { category: text(query.category, 64) }) };
+            return page(await call('list_packages', input, options), p.page, p.page_size, packageRow);
+        },
+        async get(project, packageSlug, query = {}, options) {
+            keys(record(query), ['version']);
+            const version = query.version == null ? undefined : semver(query.version);
+            return details(await call('get_package', { ...projectInput(project), slug: slug(packageSlug), ...(version === undefined ? {} : { version }) }, options), packageSlug, version);
+        },
+        async versions(project, packageSlug, query = {}, options) {
+            const p = pagination(query, 5);
+            const result = page(await call('list_versions', { ...projectInput(project), slug: slug(packageSlug), ...p }, options), p.page, p.page_size, row => versionRow(row));
+            if (new Set(result.data.map(row => row.package_id)).size > 1)
+                invalid();
+            return result;
+        },
+        async featured(project, options) { return page(await call('featured', projectInput(project), options), 1, 20, packageRow); },
+        async categories(project, options) {
+            const result = await call('categories', projectInput(project), options);
+            if (!Array.isArray(result) || result.length > 100)
+                invalid();
+            const data = result.map(value => {
+                const r = record(value);
+                return { id: uuid(r.id), slug: slug(r.slug), name: text(r.name, 128),
+                    description: nullable(r.description, v => text(v, 1000)), icon_url: nullable(r.icon_url, v => text(v, 2048)), package_count: count(r.package_count), sort_order: count(r.sort_order, -2147483648, 2147483647) };
+            });
+            if (new Set(data.map(row => row.id)).size !== data.length)
+                invalid();
+            return data;
+        },
+        async publish(project, input, options) {
+            const body = publishInput(input);
+            const result = details(await call('publish', { ...projectInput(project), body }, options), body.slug);
+            if (!result.owned || !result.versions.some(v => v.version === body.version && v.module_hash === body.module_hash))
+                invalid();
+            return result;
+        },
+        async install(project, packageSlug, input = {}, options) { return mutate('install', project, packageSlug, input, options); },
+        async update(project, packageSlug, input = {}, options) { return mutate('update', project, packageSlug, input, options); },
+        async installed(project, query = {}, options) {
+            const p = pagination(query, 20);
+            return page(await call('installed', { ...projectInput(project), ...p }, options), p.page, p.page_size, row => installationRow(row, project));
+        },
+        async getInstallation(project, id, options) { return installationRow(await call('get_installation', { ...projectInput(project), installation_id: uuid(id) }, options), project, id); },
+        async reconcile(project, id, options) { return installationRow(await call('reconcile', { ...projectInput(project), installation_id: uuid(id) }, options), project, id); },
+        async uninstall(project, id, options) {
+            const result = installationRow(await call('uninstall', { ...projectInput(project), installation_id: uuid(id) }, options), project, id);
+            if (result.status !== 'uninstalled' || result.operation || result.deployment_id || result.pending_deployment_id)
+                invalid();
+            return result;
+        },
+    };
+}

package/dist/hives-node.d.ts

@@ -0,0 +1,9 @@
+import { Genesis } from './genesis.js';
+import type { GenesisOptions } from './client.js';
+export declare function closeHivesNodeTransport(): Promise<void>;
+export declare function hivesOperationBudget(id: string): number;
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export declare function createHivesNodeTransport(opts?: GenesisOptions, callerSignal?: AbortSignal): typeof fetch;
+/** Node opt-in for Hives calls. Other services retain the caller transport. */
+export declare function createHivesNodeClient(opts?: GenesisOptions, callerSignal?: AbortSignal): Genesis;

package/dist/hives-node.js

@@ -0,0 +1,155 @@
+import { Agent } from 'undici';
+import { Genesis } from './genesis.js';
+import { operationTable } from './generated/operations.js';
+// Node's native fetch accepts a compatible per-request dispatcher. Never change
+// the global dispatcher or the portable SDK: other products retain their transport.
+const agentOptions = { headersTimeout: 340_000, bodyTimeout: 340_000, connect: { timeout: 5_000 }, connections: 4, pipelining: 1 };
+let agent;
+const nativeAgent = () => agent ??= new Agent(agentOptions);
+export async function closeHivesNodeTransport() {
+    const current = agent;
+    agent = undefined;
+    await current?.destroy();
+}
+export function hivesOperationBudget(id) {
+    if (['hives_list_buckets', 'hives_create_bucket', 'hives_get_bucket', 'hives_delete_bucket', 'hives_list_objects', 'hives_upload_object', 'hives_upload_object_by_key', 'hives_delete_object', 'hives_delete_object_by_key', 'hives_download_object_by_key', 'hives_get_cors_config', 'hives_set_cors_config', 'hives_generate_presigned_url', 'hives_reconcile'].includes(id))
+        return 100_000;
+    if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment' || id === 'hives_stop_deployment')
+        return 330_000;
+    // A live SSE subscription is bounded by its caller's window or --follow limit (at most 300 s).
+    if (id === 'hives_stream_logs')
+        return 330_000;
+    if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))
+        return 40_000;
+    if (['hives_create_function', 'hives_update_function', 'hives_delete_function'].includes(id))
+        return 100_000;
+    return 20_000;
+}
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const templatePattern = (value) => new RegExp('^' + value.split(/(\{[^}]+\})/).map((part) => part.startsWith('{') ? '[^/]+' : escape(part)).join('') + '$');
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export function createHivesNodeTransport(opts = {}, callerSignal) {
+    const supplied = opts.fetch ?? globalThis.fetch;
+    const underlying = supplied.bind(globalThis);
+    const useNative = supplied === globalThis.fetch;
+    const resolver = new Genesis(opts);
+    const routes = Object.entries(operationTable)
+        .filter(([, op]) => op.service === 'hives' && !op.internal)
+        .flatMap(([id, op]) => {
+        const direct = resolver.routing === 'direct';
+        let base;
+        try {
+            base = new URL(direct ? (opts.upstreams?.hives ?? op.upstream.base) : resolver.baseUrl);
+        }
+        catch {
+            throw new Error('Invalid Hives service address.');
+        }
+        const path = direct ? op.upstream.path : op.path;
+        const prefix = base.pathname.replace(/\/+$/, '');
+        const paths = [path];
+        if (!direct && path.startsWith('/v1/hives/'))
+            paths.push(path.replace('/v1/hives/', '/hives/v1/'));
+        return paths.map((p) => ({ id, origin: base.origin, method: direct ? op.upstream.method : op.method, pattern: templatePattern(prefix + p) }));
+    });
+    return (async (input, init = {}) => {
+        let url;
+        try {
+            url = new URL(input instanceof Request ? input.url : String(input));
+        }
+        catch {
+            throw new Error('Invalid Hives request address.');
+        }
+        const method = (init.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase();
+        const route = routes.find((entry) => entry.origin === url.origin && entry.method === method && entry.pattern.test(url.pathname));
+        if (!route)
+            return underlying(input, init);
+        const controller = new AbortController();
+        let message = 'Hives transport failed. Refresh the resource and retry.';
+        const safeError = () => new Error(message);
+        const signals = [...new Set([callerSignal, init.signal, input instanceof Request ? input.signal : undefined].filter((signal) => !!signal))];
+        const canceled = () => {
+            message = 'Hives request canceled before completion. Refresh the resource before retrying.';
+            controller.abort();
+        };
+        for (const signal of signals)
+            signal.addEventListener('abort', canceled, { once: true });
+        const timer = setTimeout(() => {
+            message = 'Hives request deadline exceeded. Refresh the resource before retrying.';
+            controller.abort();
+        }, hivesOperationBudget(route.id));
+        timer.unref();
+        let abortReject = () => { };
+        let reader;
+        let bodyController;
+        const aborted = () => {
+            abortReject(safeError());
+            bodyController?.error(safeError());
+            void reader?.cancel().catch(() => { });
+            cleanup();
+        };
+        controller.signal.addEventListener('abort', aborted, { once: true });
+        const abortPromise = new Promise((_, reject) => { abortReject = reject; });
+        void abortPromise.catch(() => { });
+        const cleanup = () => {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener('abort', canceled);
+            controller.signal.removeEventListener('abort', aborted);
+        };
+        if (signals.some((signal) => signal.aborted))
+            canceled();
+        try {
+            if (controller.signal.aborted)
+                throw safeError();
+            const requestInit = {
+                ...init, signal: controller.signal, cache: 'no-store',
+                redirect: init.redirect === 'manual' ? 'manual' : 'error',
+                ...(useNative ? { dispatcher: nativeAgent() } : {}),
+            };
+            const pending = underlying(input, requestInit);
+            // A caller transport may ignore AbortSignal. Reject on our budget anyway,
+            // and discard any late response rather than presenting an acknowledgement.
+            void pending.then((response) => { if (controller.signal.aborted)
+                void response.body?.cancel().catch(() => { }); }, () => { });
+            const response = await Promise.race([pending, abortPromise]);
+            if (controller.signal.aborted)
+                throw safeError();
+            if (!response.body) {
+                cleanup();
+                return response;
+            }
+            reader = response.body.getReader();
+            const body = new ReadableStream({
+                start(value) { bodyController = value; },
+                async pull(value) {
+                    try {
+                        const next = await reader.read();
+                        if (controller.signal.aborted)
+                            return;
+                        if (next.done) {
+                            cleanup();
+                            value.close();
+                        }
+                        else
+                            value.enqueue(next.value);
+                    }
+                    catch {
+                        cleanup();
+                        value.error(safeError());
+                    }
+                },
+                async cancel() { cleanup(); await reader.cancel().catch(() => { }); },
+            });
+            return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+        }
+        catch {
+            cleanup();
+            throw safeError();
+        }
+    });
+}
+/** Node opt-in for Hives calls. Other services retain the caller transport. */
+export function createHivesNodeClient(opts = {}, callerSignal) {
+    return new Genesis({ ...opts, fetch: createHivesNodeTransport(opts, callerSignal) });
+}