@lifesi/genesis 0.1.2 → 0.1.4

package/dist/henry.d.ts

@@ -14,6 +14,13 @@ export declare function henryModule(client: GenesisClient): {
             id: string;
         }[];
     }>;
+    receipts: {
+        /** Current standalone Henry public signer. Pin through trusted deployment custody before verifying a receipt. */
+        verificationKey: () => Promise<{
+            keyId: string;
+            publicKeyBase64: string;
+        }>;
+    };
     runs: {
         list: (page_token?: string) => Promise<{
             runs: import("./index.js").components["schemas"]["Henry.Run"][];

package/dist/henry.js

@@ -1,8 +1,31 @@
+function receiptVerificationKey(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Henry returned an invalid receipt verification key.');
+    const key = value;
+    if (Object.keys(key).length !== 2 || !Object.hasOwn(key, 'keyId') || !Object.hasOwn(key, 'publicKeyBase64')
+        || typeof key.keyId !== 'string' || !key.keyId.trim() || key.keyId.length > 256 || /[\x00-\x1f\x7f]/.test(key.keyId)
+        || typeof key.publicKeyBase64 !== 'string' || key.publicKeyBase64.length !== 44
+        || !/^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$/.test(key.publicKeyBase64)) {
+        throw new Error('Henry returned an invalid receipt verification key.');
+    }
+    return { keyId: key.keyId, publicKeyBase64: key.publicKeyBase64 };
+}
 /** Henry always derives its organization from the gateway's verified caller. */
 export function henryModule(client) {
     return {
         config: () => client.request('henry_getConfig'),
         credential: (api_key) => client.request('henry_putCredential', { body: { api_key } }),
+        receipts: {
+            /** Current standalone Henry public signer. Pin through trusted deployment custody before verifying a receipt. */
+            verificationKey: async () => {
+                try {
+                    return receiptVerificationKey(await client.request('henry_getReceiptVerificationKey'));
+                }
+                catch {
+                    throw new Error('Henry returned an invalid receipt verification key.');
+                }
+            },
+        },
         runs: {
             list: (page_token) => client.request('henry_listRuns', page_token ? { page_token } : {}),
             create: (body) => client.request('henry_createRun', { body: { ...body, run_id: body.run_id ?? globalThis.crypto.randomUUID() } }),

package/dist/hives-functions.d.ts

@@ -12,4 +12,4 @@ export declare function validateHivesInvocation(input: unknown): asserts input i
 /** Safe display/transport headers; customer headers never establish identity. */
 export declare function hivesFunctionResponseHeaders(headers: Headers): Headers;
 /** Metadata contracts cannot accidentally expose an upstream env/ciphertext field. */
-export declare function hivesFunctionMetadata(input: unknown, project: unknown): Record<string, unknown>;
+export declare function hivesFunctionMetadata(input: unknown, project: unknown, expectedId?: unknown): Record<string, unknown>;

package/dist/hives-functions.js

@@ -84,11 +84,13 @@ export function hivesFunctionResponseHeaders(headers) {
     return safe;
 }
 /** Metadata contracts cannot accidentally expose an upstream env/ciphertext field. */
-export function hivesFunctionMetadata(input, project) {
+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.js

@@ -14,7 +14,7 @@ export async function closeHivesNodeTransport() {
 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')
+    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;

package/dist/hives-resources-transport.js

@@ -14,7 +14,7 @@ export function resourceError(status, id) {
                 : status === 503 ? 'Hives outcome is unavailable. Read persisted state or reconcile before another mutation.'
                     : 'Hives resource request failed. Check the request and persisted state; no automatic retry was made.' });
 }
-export const isHivesResourceOperation = (id) => /^(?:hives_.*_native_queue|hives_(?:list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key)?|delete_object(?:_by_key)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
+export const isHivesResourceOperation = (id) => /^(?:hives_marketplace_(?:categories|featured|installed|get_installation|uninstall|reconcile|list_packages|publish|get_package|install|update|list_versions)|hives_.*_native_queue|hives_(?:(?:list_volumes|create_volume|get_volume|delete_volume|mount_volume|unmount_volume)|list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key)?|delete_object(?:_by_key)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
 export const isHivesObjectUpload = (id) => id === 'hives_upload_object_by_key' || id === 'hives_upload_object';
 /** Shared-client hook proposal: snapshot only the two real raw Cells upload operations. */
 export async function hivesObjectBody(value) {

package/dist/hives-volumes.d.ts

@@ -0,0 +1,64 @@
+import type { GenesisClient } from './client.js';
+import { type HivesResourceOptions } from './hives-resources-transport.js';
+declare const states: readonly ["creating", "available", "attaching", "attached", "detaching", "deleting", "failed"];
+export interface HivesVolume {
+    id: string;
+    project_id: string;
+    name: string;
+    size_gib: number;
+    backing_bytes: number;
+    capacity_bytes: number | null;
+    used_bytes: number | null;
+    storage_class: 'local';
+    access_mode: 'read_write_once';
+    state: typeof states[number];
+    operation_pending: boolean;
+    generation: number;
+    mount_path: string | null;
+    attached_to: string | null;
+    read_only: boolean | null;
+    created_at: string;
+    updated_at: string;
+}
+export type HivesVolumeCreate = {
+    name: string;
+    storage_class?: 'local';
+    access_mode?: 'read_write_once';
+} & ({
+    size_mib: number;
+    size_gib?: never;
+} | {
+    size_gib: 1;
+    size_mib?: never;
+});
+export interface HivesVolumeMount {
+    target_id: string;
+    mount_path: string;
+    read_only: boolean;
+}
+export interface HivesVolumePage {
+    volumes: HivesVolume[];
+    pagination: {
+        page: number;
+        per_page: number;
+        total: number;
+        total_pages: number;
+    };
+}
+/** Persisted project storage. A failed acknowledgement never triggers an automatic write retry. */
+export declare function hivesVolumes(client: GenesisClient): {
+    list(project: string, query?: {
+        page?: number;
+        per_page?: number;
+    }, options?: HivesResourceOptions): Promise<HivesVolumePage>;
+    get(project: string, id: string, options?: HivesResourceOptions): Promise<HivesVolume>;
+    create(project: string, input: HivesVolumeCreate, options?: HivesResourceOptions): Promise<HivesVolume>;
+    mount(project: string, id: string, input: HivesVolumeMount, options?: HivesResourceOptions): Promise<HivesVolume>;
+    unmount(project: string, id: string, options?: HivesResourceOptions): Promise<HivesVolume>;
+    remove(project: string, id: string, options?: HivesResourceOptions): Promise<{
+        success: true;
+        id: string;
+        message: string;
+    }>;
+};
+export {};

package/dist/hives-volumes.js

@@ -0,0 +1,117 @@
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+const MIB = 1024 * 1024;
+const states = ['creating', 'available', 'attaching', 'attached', 'detaching', 'deleting', 'failed'];
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw resourceError(0);
+    return value;
+}
+function text(value, max = 128) {
+    if (typeof value !== 'string' || !value || value.length > max || /[\u0000-\u001f\u007f]/.test(value))
+        throw resourceError(0);
+    return value;
+}
+function count(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw resourceError(0);
+    return value;
+}
+function date(value) { const result = text(value, 64); if (!Number.isFinite(Date.parse(result)))
+    throw resourceError(0); return result; }
+function volume(value, project, expectedId) {
+    const row = object(value);
+    if (row.project_id !== project || row.storage_class !== 'local' || row.access_mode !== 'read_write_once'
+        || !states.includes(row.state) || typeof row.operation_pending !== 'boolean')
+        throw resourceError(0);
+    const id = hivesResourceId(text(row.id));
+    if (expectedId && id !== expectedId)
+        throw resourceError(0);
+    const backing = count(row.backing_bytes);
+    const capacity = row.capacity_bytes === null ? null : count(row.capacity_bytes);
+    const used = row.used_bytes === null ? null : count(row.used_bytes);
+    if (backing < 32 * MIB || backing > 1024 * MIB || row.size_gib !== backing / (1024 * MIB)
+        || capacity !== null && capacity > backing || used !== null && (capacity === null || used > capacity))
+        throw resourceError(0);
+    const path = row.mount_path === null ? null : text(row.mount_path, 512);
+    const attached = row.attached_to === null ? null : hivesResourceId(text(row.attached_to));
+    if ((path === null) !== (attached === null) || (attached === null ? row.read_only !== null : typeof row.read_only !== 'boolean'))
+        throw resourceError(0);
+    const generation = count(row.generation);
+    if (generation < 1)
+        throw resourceError(0);
+    return { id, project_id: project, name: text(row.name, 64), size_gib: backing / (1024 * MIB), backing_bytes: backing,
+        capacity_bytes: capacity, used_bytes: used, storage_class: 'local', access_mode: 'read_write_once',
+        state: row.state, operation_pending: row.operation_pending, generation,
+        mount_path: path, attached_to: attached, read_only: row.read_only,
+        created_at: date(row.created_at), updated_at: date(row.updated_at) };
+}
+/** Persisted project storage. A failed acknowledgement never triggers an automatic write retry. */
+export function hivesVolumes(client) {
+    const ids = (project, id) => ({ project_id: hivesResourceId(project), ...(id === undefined ? {} : { volume_id: hivesResourceId(id) }) });
+    const call = (id, input, options) => hivesResourceCall(client, id, input, options);
+    return {
+        async list(project, query = {}, options) {
+            const page = query.page ?? 1;
+            const perPage = query.per_page ?? 25;
+            if (Object.keys(query).some(key => !['page', 'per_page'].includes(key)) || !Number.isSafeInteger(page) || page < 1 || page > 10000
+                || !Number.isSafeInteger(perPage) || perPage < 1 || perPage > 100)
+                throw resourceError(0);
+            const result = object(await call('hives_list_volumes', { ...ids(project), page, per_page: perPage }, options));
+            const pagination = object(result.pagination);
+            const total = count(pagination.total);
+            const pages = count(pagination.total_pages);
+            if (pagination.page !== page || pagination.per_page !== perPage || pages !== Math.ceil(total / perPage)
+                || !Array.isArray(result.volumes) || result.volumes.length > perPage)
+                throw resourceError(0);
+            const volumes = result.volumes.map(row => volume(row, project));
+            if (new Set(volumes.map(row => row.id)).size !== volumes.length)
+                throw resourceError(0);
+            return { volumes, pagination: { page, per_page: perPage, total, total_pages: pages } };
+        },
+        async get(project, id, options) { return volume(await call('hives_get_volume', ids(project, id), options), project, id); },
+        async create(project, input, options) {
+            const body = object(input);
+            const name = text(body.name, 64);
+            let size;
+            if (body.size_mib !== undefined && body.size_gib === undefined)
+                size = count(body.size_mib);
+            else if (body.size_mib === undefined && body.size_gib === 1)
+                size = 1024;
+            else
+                throw resourceError(0);
+            if (name.trim() !== name || size < 32 || size > 1024 || body.storage_class !== undefined && body.storage_class !== 'local'
+                || body.access_mode !== undefined && body.access_mode !== 'read_write_once'
+                || Object.keys(body).some(key => !['name', 'size_mib', 'size_gib', 'storage_class', 'access_mode'].includes(key)))
+                throw resourceError(0);
+            const result = volume(await call('hives_create_volume', { ...ids(project), body: { name, size_mib: size, storage_class: 'local', access_mode: 'read_write_once' } }, options), project);
+            if (result.name !== name || result.backing_bytes !== size * MIB)
+                throw resourceError(0);
+            return result;
+        },
+        async mount(project, id, input, options) {
+            const body = object(input);
+            const target = hivesResourceId(text(body.target_id));
+            const path = text(body.mount_path, 128);
+            if (!/^\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/.test(path) || typeof body.read_only !== 'boolean'
+                || Object.keys(body).some(key => !['target_id', 'mount_path', 'read_only'].includes(key)))
+                throw resourceError(0);
+            const readOnly = body.read_only;
+            const result = volume(await call('hives_mount_volume', { ...ids(project, id), body: { target_id: target, mount_path: path, read_only: readOnly } }, options), project, id);
+            if (result.attached_to !== target || result.mount_path !== path || result.read_only !== readOnly)
+                throw resourceError(0);
+            return result;
+        },
+        async unmount(project, id, options) {
+            const result = volume(await call('hives_unmount_volume', ids(project, id), options), project, id);
+            if (result.state !== 'available' || result.operation_pending || result.attached_to !== null || result.mount_path !== null || result.read_only !== null)
+                throw resourceError(0);
+            return result;
+        },
+        async remove(project, id, options) {
+            const result = object(await call('hives_delete_volume', ids(project, id), options));
+            if (result.id !== id || result.success !== true)
+                throw resourceError(0);
+            return { success: true, id, message: text(result.message, 256) };
+        },
+    };
+}

package/dist/index.d.ts

@@ -14,4 +14,6 @@ export { dialsModule, dialsEmergencyAddressFeedback, type DialsEmergencyAddressF
 export { hivesObjectKey, type HivesBucket, type HivesObject, type HivesObjectAcknowledgement, type HivesObjectList, type HivesCorsRule, type HivesCreateBucket, type HivesPresign, type HivesPresignedUrl } from './hives-cells.js';
 export { hivesQueueBody, type HivesQueue, type HivesQueueConfig, type HivesQueueCreate, type HivesQueueSend, type HivesQueueDelivery, type HivesDeadLetter, type HivesDeadLetterStats } from './hives-queues.js';
 export type { HivesRuntime, HivesRuntimeSelection } from './hives-runtimes.js';
+export type { HivesVolume, HivesVolumeCreate, HivesVolumeMount, HivesVolumePage } from './hives-volumes.js';
 export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES, type HivesResourceOptions } from './hives-resources-transport.js';
+export type { HivesMarketplacePackage, HivesMarketplaceVersion, HivesMarketplaceInstallation, HivesMarketplaceCategory, HivesMarketplacePage, HivesMarketplacePublish, HivesMarketplaceInstall, HivesMarketplaceSearch, HivesMarketplaceDetail } from './hives-marketplace.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifesi/genesis",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/l1felabs/genesis-api.git",