@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/hives-functions.js

@@ -0,0 +1,185 @@
+import { GenesisError } from './errors.js';
+/** The service separately bounds its serialized guest stdin envelope at 10 MiB. */
+export const MAX_FUNCTION_BODY_BYTES = 10 * 1024 * 1024;
+export const MAX_FUNCTION_JSON_BYTES = 16 * 1024 * 1024;
+const executionId = /^exec_[a-f0-9]{32}$/;
+export function hivesInvokeHeaders(options) {
+    if (options.idempotencyKey === undefined)
+        return {};
+    if (!/^[A-Za-z0-9_.:@-]{1,128}$/.test(options.idempotencyKey))
+        throw new Error('Use one persisted Hives idempotency key of 1–128 identifier characters.');
+    return { 'idempotency-key': options.idempotencyKey };
+}
+export function hivesOperationStatus(value, expected) {
+    const row = value;
+    const keys = ['operation_id', 'state', 'code', 'funding_source', 'reservation_id', 'retry_execution'];
+    if (!executionId.test(expected) || !row || typeof row !== 'object' || Array.isArray(row)
+        || Object.keys(row).length !== keys.length || keys.some(key => !Object.hasOwn(row, key))
+        || row.operation_id !== expected || row.retry_execution !== false
+        || !['prepared', 'reserve_unknown', 'reserved', 'dispatch_unknown', 'dispatch_authorized', 'dispatched', 'settle_unknown', 'settled', 'release_pending', 'released'].includes(row.state)
+        || typeof row.code !== 'string' || !/^[a-z_]{1,80}$/.test(row.code)
+        || row.funding_source !== null && row.funding_source !== 'sandbox_allowance' && row.funding_source !== 'stripe_test_metered'
+        || row.reservation_id !== null && !/^gfr_[A-Za-z0-9_.:@-]{1,124}$/.test(row.reservation_id)) {
+        throw new Error('Hives returned invalid or mismatched operation status. Keep the original idempotency key.');
+    }
+    return row;
+}
+export class HivesOperationError extends GenesisError {
+    operation;
+    constructor(status, operation) {
+        super({ status, type: 'hives_operation_unresolved', message: 'Read the original Hives operation status. Do not invoke with a new idempotency key.', body: operation });
+        this.operation = operation;
+    }
+}
+/** Read only the small platform receipt; never retain reflected guest request data. */
+export async function hivesOperationError(response) {
+    const expected = response.headers.get('x-hives-operation-id');
+    if (!expected || !executionId.test(expected) || !response.body)
+        return undefined;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 2048) {
+                await reader.cancel();
+                return undefined;
+            }
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return new HivesOperationError(response.status, hivesOperationStatus(JSON.parse(new TextDecoder().decode(bytes)), expected));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+const reservedHeaders = new Set(['host', 'connection', 'content-length', 'transfer-encoding', 'keep-alive',
+    'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'upgrade', 'set-cookie', 'clear-site-data',
+    'authorization', 'cookie', 'forwarded', 'origin', 'referer', 'x-org-id', 'x-workspace-id', 'x-project-id',
+    'x-admin-token', 'x-tenant-id', 'x-cold-start']);
+const platformHeader = (name) => /^x-(?:auth|genesis|life|l1fe|hives|forwarded|execution)-/.test(name);
+const bytes = (value) => new TextEncoder().encode(value).length;
+const fail = () => { throw new Error('Invalid function request. Check method, path, headers, exclusive body encoding and size limits.'); };
+export function validateHivesInvocation(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        fail();
+    const r = input;
+    if (Object.keys(r).some((k) => !['method', 'path', 'headers', 'body', 'body_base64'].includes(k)))
+        fail();
+    if (r.method !== undefined && (typeof r.method !== 'string' || bytes(r.method) > 64 || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(r.method)))
+        fail();
+    if (r.path !== undefined && (typeof r.path !== 'string' || !r.path.startsWith('/') || r.path.startsWith('//') || r.path.includes('#') || bytes(r.path) > 8192 || /[\s\u0000-\u001f\u007f]/.test(r.path)))
+        fail();
+    let headerBytes = 0;
+    if (r.headers !== undefined) {
+        if (!r.headers || typeof r.headers !== 'object' || Array.isArray(r.headers) || Object.keys(r.headers).length > 128)
+            fail();
+        for (const [key, value] of Object.entries(r.headers)) {
+            if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(key) || typeof value !== 'string' || /[\u0000-\u0008\u000a-\u001f\u007f]/.test(value)
+                || reservedHeaders.has(key.toLowerCase()) || platformHeader(key.toLowerCase()))
+                fail();
+            headerBytes += bytes(key) + bytes(value);
+            if (headerBytes > 64 * 1024)
+                fail();
+        }
+    }
+    let size = 0;
+    if (r.body_base64 !== undefined) {
+        const value = r.body_base64;
+        if (r.body != null || typeof value !== 'string' || value.length > Math.ceil(MAX_FUNCTION_BODY_BYTES / 3) * 4
+            || value.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+            fail();
+        try {
+            const bytes = atob(value);
+            if (btoa(bytes) !== value)
+                fail();
+            size = bytes.length;
+        }
+        catch {
+            fail();
+        }
+    }
+    else if (r.body != null) {
+        let value;
+        try {
+            value = typeof r.body === 'string' ? r.body : JSON.stringify(r.body);
+        }
+        catch {
+            fail();
+        }
+        if (value === undefined)
+            fail();
+        size = new TextEncoder().encode(value).length;
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(r);
+    }
+    catch {
+        fail();
+    }
+    if (size + headerBytes > MAX_FUNCTION_BODY_BYTES || !serialized || new TextEncoder().encode(serialized).length > MAX_FUNCTION_JSON_BYTES)
+        fail();
+}
+/** Safe display/transport headers; customer headers never establish identity. */
+export function hivesFunctionResponseHeaders(headers) {
+    const blocked = new Set(['connection', 'keep-alive', 'transfer-encoding', 'upgrade', 'proxy-authenticate', 'proxy-authorization',
+        'te', 'trailer', 'content-length', 'content-encoding', 'set-cookie', 'clear-site-data', 'authorization', 'cookie', 'forwarded', 'host', 'x-org-id', 'x-workspace-id', 'x-project-id', 'x-admin-token', 'x-tenant-id', 'x-hives-guest-status']);
+    for (const value of (headers.get('connection') ?? '').split(','))
+        blocked.add(value.trim().toLowerCase());
+    const safe = new Headers();
+    headers.forEach((value, name) => {
+        if (!blocked.has(name) && (!platformHeader(name) || ['x-execution-id', 'x-execution-duration-ms'].includes(name)))
+            safe.set(name, value);
+    });
+    const operation = headers.get('x-hives-operation-id');
+    if (operation && executionId.test(operation) && operation === headers.get('x-execution-id'))
+        safe.set('x-hives-operation-id', operation);
+    const observation = headers.get('x-execution-observation-v1');
+    if (observation && validObservation(observation))
+        safe.set('x-execution-observation-v1', observation);
+    safe.set('cache-control', 'no-store');
+    return safe;
+}
+function validObservation(encoded) {
+    if (encoded.length > 2048 || !/^[A-Za-z0-9_-]+$/.test(encoded))
+        return false;
+    try {
+        const value = JSON.parse(atob(encoded.replace(/-/g, '+').replace(/_/g, '/')));
+        const numbers = ['reserved_memory_bytes', 'reserved_cpu_millis', 'admission_wait_us'];
+        const nullable = ['executor_poll_cpu_ns', 'exported_linear_memory_bytes'];
+        const keys = [...numbers, ...nullable, 'version', 'cpu_scope', 'complete_execution_cpu', 'peak_linear_memory_bytes', 'execution_resident_memory_bytes'];
+        return value && typeof value === 'object' && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key))
+            && value.version === 1 && value.cpu_scope === 'executor_thread_polls' && value.complete_execution_cpu === false
+            && value.peak_linear_memory_bytes === null && value.execution_resident_memory_bytes === null
+            && numbers.every(key => Number.isSafeInteger(value[key]) && value[key] >= 0)
+            && nullable.every(key => value[key] === null || Number.isSafeInteger(value[key]) && value[key] >= 0);
+    }
+    catch {
+        return false;
+    }
+}
+/** Metadata contracts cannot accidentally expose an upstream env/ciphertext field. */
+export function hivesFunctionMetadata(input, project, expectedId) {
+    if (!input || typeof input !== 'object' || input.project_id !== project) {
+        throw new Error('Hives returned invalid or wrong-project function metadata.');
+    }
+    const row = input;
+    if (expectedId !== undefined && row.id !== expectedId)
+        throw new Error('Hives returned mismatched function metadata.');
+    return Object.fromEntries(['id', 'tenant_id', 'project_id', 'name', 'description', 'handler', 'route', 'memory_mb', 'timeout_ms',
+        'status', 'invocations', 'avg_duration_ms', 'created_at', 'updated_at'].map((key) => [key, row[key]]));
+}

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,152 @@
+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;
+    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) });
+}