@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/orgs.d.ts

@@ -0,0 +1,405 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+type Page = {
+    after?: number;
+    limit?: number;
+};
+type Version = number | string;
+/** A downloaded Orgs document: its bytes, media type and the sha256 the service reported (hex). */
+export interface OrgsDocumentContent {
+    bytes: Uint8Array;
+    contentType: string;
+    sha256: string | null;
+}
+/**
+ * Orgs (legal entities): entities, the registered agent, seats, resolutions and votes, documents and
+ * signatures, filings, formation rehearsals and the hash-chained record. PATCH, PUT and DELETE take
+ * the `version` you read (sent as If-Match); a stale one is a 409. Formation never files or pays.
+ */
+export declare function orgsEntitiesModule(client: GenesisClient): {
+    whoami: () => Promise<{
+        org: string;
+        principal: string;
+        kind: "api_key" | "m2m_token" | "bridge_session";
+        scopes: string[];
+    }>;
+    portals: () => Promise<{
+        data: import("./index.js").components["schemas"]["Orgs.Portal"][];
+    }>;
+    entities: {
+        list: (includeArchived?: boolean) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.Entity"][];
+        }>;
+        get: (entity: string) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        create: (body: In<"orgs_create_entity">["body"]) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        update: (entity: string, version: Version, body: In<"orgs_update_entity">["body"]) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        archive: (entity: string, version: Version) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        setRegisteredAgent: (entity: string, version: Version, body: In<"orgs_set_registered_agent">["body"]) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        removeRegisteredAgent: (entity: string, version: Version) => Promise<{
+            id: string;
+            legal_name: string;
+            kind: import("./index.js").components["schemas"]["Orgs.EntityKind"];
+            jurisdiction: string;
+            purpose?: string | null;
+            management: import("./index.js").components["schemas"]["Orgs.Management"];
+            addresses?: import("./index.js").components["schemas"]["Orgs.Addresses"];
+            registered_agent?: import("./index.js").components["schemas"]["Orgs.RegisteredAgent"] | null;
+            registered_agent_since?: string | null;
+            file_number?: string | null;
+            formed_on?: string | null;
+            auto_org_id?: string | null;
+            status: "draft" | "forming" | "formed" | "active" | "suspended" | "dissolved" | "archived";
+            version: number;
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        seats: (entity: string, includeEnded?: boolean) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.Seat"][];
+        }>;
+        createSeat: (entity: string, body: In<"orgs_create_seat">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            role: import("./index.js").components["schemas"]["Orgs.SeatRole"];
+            title?: string | null;
+            holder: import("./index.js").components["schemas"]["Orgs.Holder"];
+            voting_weight: number;
+            status: "active" | "ended";
+            started_at?: string | null;
+            ended_at?: string | null;
+            version: number;
+        }>;
+        resolutions: (entity: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.Resolution"][];
+        }>;
+        createResolution: (entity: string, body: In<"orgs_create_resolution">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            body_kind: "board" | "members" | "managers";
+            title: string;
+            text: string;
+            votes: import("./index.js").components["schemas"]["Orgs.Vote"][];
+            status: "draft" | "adopted" | "rejected" | "withdrawn";
+            decided_at?: string | null;
+            version: number;
+        }>;
+        documents: (entity: string, kind?: In<"orgs_list_documents">["kind"]) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.Document"][];
+        }>;
+        addDocument: (entity: string, body: In<"orgs_add_document">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.DocumentKind"];
+            title: string;
+            media_type: string;
+            bytes: number;
+            sha256: string;
+            storage?: {
+                kind?: "gcs" | "boxes";
+                file_id?: string;
+            };
+            source?: string | null;
+            signatures?: import("./index.js").components["schemas"]["Orgs.Signature"][];
+            created_by?: string;
+            created_at?: string;
+        }>;
+        filings: (entity: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.Filing"][];
+        }>;
+        createFiling: (entity: string, body: In<"orgs_create_filing">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.FilingKind"];
+            jurisdiction?: string;
+            status: "draft" | "prepared" | "ready_to_submit" | "submitted" | "accepted" | "rejected" | "cancelled";
+            due_on?: string | null;
+            packet?: Record<string, never> | null;
+            fee?: unknown;
+            receipt?: unknown;
+            job_id?: string | null;
+            version: number;
+        }>;
+        /** Prepare the formation packet and queue a rehearsal run (202), or with `dry_run: true` only build the packet (200). */
+        requestFormation: (entity: string, body: In<"orgs_request_formation">["body"]) => Promise<{
+            packet: import("./index.js").components["schemas"]["Orgs.FormationPacket"];
+        }>;
+        formationJobs: (entity: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.FormationJob"][];
+        }>;
+        record: (entity: string, page?: Page) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.RecordEntry"][];
+            next_after?: number | null;
+        }>;
+        verifyRecord: (entity: string) => Promise<{
+            ok: boolean;
+            entries: number;
+            head?: string | null;
+            broken_at?: number | null;
+        }>;
+    };
+    seats: {
+        get: (seat: string) => Promise<{
+            id: string;
+            entity_id: string;
+            role: import("./index.js").components["schemas"]["Orgs.SeatRole"];
+            title?: string | null;
+            holder: import("./index.js").components["schemas"]["Orgs.Holder"];
+            voting_weight: number;
+            status: "active" | "ended";
+            started_at?: string | null;
+            ended_at?: string | null;
+            version: number;
+        }>;
+        update: (seat: string, version: Version, body: In<"orgs_update_seat">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            role: import("./index.js").components["schemas"]["Orgs.SeatRole"];
+            title?: string | null;
+            holder: import("./index.js").components["schemas"]["Orgs.Holder"];
+            voting_weight: number;
+            status: "active" | "ended";
+            started_at?: string | null;
+            ended_at?: string | null;
+            version: number;
+        }>;
+        end: (seat: string, version: Version) => Promise<{
+            id: string;
+            entity_id: string;
+            role: import("./index.js").components["schemas"]["Orgs.SeatRole"];
+            title?: string | null;
+            holder: import("./index.js").components["schemas"]["Orgs.Holder"];
+            voting_weight: number;
+            status: "active" | "ended";
+            started_at?: string | null;
+            ended_at?: string | null;
+            version: number;
+        }>;
+    };
+    resolutions: {
+        get: (resolution: string) => Promise<{
+            id: string;
+            entity_id: string;
+            body_kind: "board" | "members" | "managers";
+            title: string;
+            text: string;
+            votes: import("./index.js").components["schemas"]["Orgs.Vote"][];
+            status: "draft" | "adopted" | "rejected" | "withdrawn";
+            decided_at?: string | null;
+            version: number;
+        }>;
+        vote: (resolution: string, body: In<"orgs_vote">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            body_kind: "board" | "members" | "managers";
+            title: string;
+            text: string;
+            votes: import("./index.js").components["schemas"]["Orgs.Vote"][];
+            status: "draft" | "adopted" | "rejected" | "withdrawn";
+            decided_at?: string | null;
+            version: number;
+        }>;
+    };
+    documents: {
+        get: (document: string) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.DocumentKind"];
+            title: string;
+            media_type: string;
+            bytes: number;
+            sha256: string;
+            storage?: {
+                kind?: "gcs" | "boxes";
+                file_id?: string;
+            };
+            source?: string | null;
+            signatures?: import("./index.js").components["schemas"]["Orgs.Signature"][];
+            created_by?: string;
+            created_at?: string;
+        }>;
+        /** The document's raw bytes, its content type and the sha256 the service reported. */
+        content: (document: string, init?: {
+            signal?: AbortSignal;
+        }) => Promise<OrgsDocumentContent>;
+        sign: (document: string, body: In<"orgs_sign_document">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.DocumentKind"];
+            title: string;
+            media_type: string;
+            bytes: number;
+            sha256: string;
+            storage?: {
+                kind?: "gcs" | "boxes";
+                file_id?: string;
+            };
+            source?: string | null;
+            signatures?: import("./index.js").components["schemas"]["Orgs.Signature"][];
+            created_by?: string;
+            created_at?: string;
+        }>;
+    };
+    filings: {
+        get: (filing: string) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.FilingKind"];
+            jurisdiction?: string;
+            status: "draft" | "prepared" | "ready_to_submit" | "submitted" | "accepted" | "rejected" | "cancelled";
+            due_on?: string | null;
+            packet?: Record<string, never> | null;
+            fee?: unknown;
+            receipt?: unknown;
+            job_id?: string | null;
+            version: number;
+        }>;
+        update: (filing: string, version: Version, body: In<"orgs_update_filing">["body"]) => Promise<{
+            id: string;
+            entity_id: string;
+            kind: import("./index.js").components["schemas"]["Orgs.FilingKind"];
+            jurisdiction?: string;
+            status: "draft" | "prepared" | "ready_to_submit" | "submitted" | "accepted" | "rejected" | "cancelled";
+            due_on?: string | null;
+            packet?: Record<string, never> | null;
+            fee?: unknown;
+            receipt?: unknown;
+            job_id?: string | null;
+            version: number;
+        }>;
+    };
+    formationJobs: {
+        get: (job: string) => Promise<{
+            id: string;
+            entity_id: string;
+            filing_id?: string | null;
+            portal?: string;
+            mode?: "rehearsal";
+            runtime?: {
+                kind?: "panes" | "rigs" | "shells";
+                instance_id?: string | null;
+            };
+            model?: string | null;
+            status: "queued" | "running" | "stopped_at_submit" | "needs_attention" | "failed" | "cancelled";
+            stop_reason?: string | null;
+            error?: unknown;
+            turns?: number;
+            actions?: number;
+            usage?: unknown;
+            requested_by?: string;
+            started_at?: string | null;
+            finished_at?: string | null;
+            version?: number;
+        }>;
+        steps: (job: string, page?: Page) => Promise<{
+            data: import("./index.js").components["schemas"]["Orgs.FormationStep"][];
+            next_after?: number | null;
+        }>;
+        cancel: (job: string) => Promise<{
+            id: string;
+            entity_id: string;
+            filing_id?: string | null;
+            portal?: string;
+            mode?: "rehearsal";
+            runtime?: {
+                kind?: "panes" | "rigs" | "shells";
+                instance_id?: string | null;
+            };
+            model?: string | null;
+            status: "queued" | "running" | "stopped_at_submit" | "needs_attention" | "failed" | "cancelled";
+            stop_reason?: string | null;
+            error?: unknown;
+            turns?: number;
+            actions?: number;
+            usage?: unknown;
+            requested_by?: string;
+            started_at?: string | null;
+            finished_at?: string | null;
+            version?: number;
+        }>;
+    };
+};
+export {};

package/dist/orgs.js

@@ -0,0 +1,63 @@
+import { ifMatchHeaders } from './idempotency.js';
+/**
+ * Orgs (legal entities): entities, the registered agent, seats, resolutions and votes, documents and
+ * signatures, filings, formation rehearsals and the hash-chained record. PATCH, PUT and DELETE take
+ * the `version` you read (sent as If-Match); a stale one is a 409. Formation never files or pays.
+ */
+export function orgsEntitiesModule(client) {
+    const guarded = (id, input, version) => client.request(id, input, { headers: ifMatchHeaders(id, version) });
+    return {
+        whoami: () => client.request('orgs_whoami'),
+        portals: () => client.request('orgs_list_portals'),
+        entities: {
+            list: (includeArchived) => client.request('orgs_list_entities', includeArchived === undefined ? {} : { include_archived: includeArchived }),
+            get: (entity) => client.request('orgs_get_entity', { entity }),
+            create: (body) => client.request('orgs_create_entity', { body }),
+            update: (entity, version, body) => guarded('orgs_update_entity', { entity, body }, version),
+            archive: (entity, version) => guarded('orgs_archive_entity', { entity }, version),
+            setRegisteredAgent: (entity, version, body) => guarded('orgs_set_registered_agent', { entity, body }, version),
+            removeRegisteredAgent: (entity, version) => guarded('orgs_remove_registered_agent', { entity }, version),
+            seats: (entity, includeEnded) => client.request('orgs_list_seats', includeEnded === undefined ? { entity } : { entity, include_ended: includeEnded }),
+            createSeat: (entity, body) => client.request('orgs_create_seat', { entity, body }),
+            resolutions: (entity) => client.request('orgs_list_resolutions', { entity }),
+            createResolution: (entity, body) => client.request('orgs_create_resolution', { entity, body }),
+            documents: (entity, kind) => client.request('orgs_list_documents', kind ? { entity, kind } : { entity }),
+            addDocument: (entity, body) => client.request('orgs_add_document', { entity, body }),
+            filings: (entity) => client.request('orgs_list_filings', { entity }),
+            createFiling: (entity, body) => client.request('orgs_create_filing', { entity, body }),
+            /** Prepare the formation packet and queue a rehearsal run (202), or with `dry_run: true` only build the packet (200). */
+            requestFormation: (entity, body) => client.request('orgs_request_formation', { entity, body }),
+            formationJobs: (entity) => client.request('orgs_list_formation_jobs', { entity }),
+            record: (entity, page = {}) => client.request('orgs_get_record', { entity, ...page }),
+            verifyRecord: (entity) => client.request('orgs_verify_record', { entity }),
+        },
+        seats: {
+            get: (seat) => client.request('orgs_get_seat', { seat }),
+            update: (seat, version, body) => guarded('orgs_update_seat', { seat, body }, version),
+            end: (seat, version) => guarded('orgs_end_seat', { seat }, version),
+        },
+        resolutions: {
+            get: (resolution) => client.request('orgs_get_resolution', { resolution }),
+            vote: (resolution, body) => client.request('orgs_vote', { resolution, body }),
+        },
+        documents: {
+            get: (document) => client.request('orgs_get_document', { document }),
+            /** The document's raw bytes, its content type and the sha256 the service reported. */
+            content: async (document, init = {}) => {
+                const res = await client.raw('orgs_get_document_content', { document }, init);
+                return { bytes: new Uint8Array(await res.arrayBuffer()), contentType: res.headers.get('content-type') ?? 'application/octet-stream',
+                    sha256: res.headers.get('x-content-sha256') };
+            },
+            sign: (document, body) => client.request('orgs_sign_document', { document, body }),
+        },
+        filings: {
+            get: (filing) => client.request('orgs_get_filing', { filing }),
+            update: (filing, version, body) => guarded('orgs_update_filing', { filing, body }, version),
+        },
+        formationJobs: {
+            get: (job) => client.request('orgs_get_formation_job', { job }),
+            steps: (job, page = {}) => client.request('orgs_list_formation_steps', { job, ...page }),
+            cancel: (job) => client.request('orgs_cancel_formation_job', { job }),
+        },
+    };
+}

package/dist/relays-enrollment.d.ts

@@ -0,0 +1,33 @@
+import type { GenesisClient } from './client.js';
+export declare const isRelaysEnrollmentOperation: (id: string) => id is "relays_getEnrollment" | "relays_enroll";
+/** Read status or send one explicit bodyless enrollment. No inferred tenant or mutation replay. */
+export declare function relaysEnrollmentTransport(options: {
+    operationId: string;
+    input: Record<string, unknown>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function relaysEnrollment(client: GenesisClient): {
+    get: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        state: "ready" | "not_enrolled";
+        organizationId: string;
+        projectId: string;
+        workspaceId: string;
+        resourceEnvironment: "sandbox";
+    }>;
+    activate: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        state: "ready";
+        organizationId: string;
+        projectId: string;
+        workspaceId: string;
+        resourceEnvironment: "sandbox";
+        created: boolean;
+    }>;
+};

package/dist/relays-enrollment.js

@@ -0,0 +1,115 @@
+import { GenesisError } from './errors.js';
+export const isRelaysEnrollmentOperation = (id) => id === 'relays_getEnrollment' || id === 'relays_enroll';
+const nativeId = (value, prefix) => typeof value === 'string'
+    && value.startsWith(prefix) && /^[A-Za-z0-9_-]{1,128}$/.test(value.slice(prefix.length));
+/** Read status or send one explicit bodyless enrollment. No inferred tenant or mutation replay. */
+export async function relaysEnrollmentTransport(options) {
+    const write = options.operationId === 'relays_enroll';
+    const error = (status, type) => new GenesisError({ status, type, operationId: options.operationId,
+        message: 'Relays enrollment was not confirmed. Read enrollment status before explicitly trying another activation.' });
+    if (options.routing !== 'gateway' || !options.input || typeof options.input !== 'object'
+        || Array.isArray(options.input) || Object.keys(options.input).length)
+        throw error(0, 'invalid_request');
+    const controller = new AbortController();
+    const cancel = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', cancel, { once: true });
+    if (options.signal?.aborted)
+        cancel();
+    const timer = setTimeout(() => controller.abort(), 20_000);
+    async function bounded(promise) {
+        controller.signal.throwIfAborted();
+        let abort = () => { };
+        try {
+            return await Promise.race([promise, new Promise((_, reject) => {
+                    abort = () => reject(error(0, 'transport_error'));
+                    controller.signal.addEventListener('abort', abort, { once: true });
+                })]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    }
+    try {
+        controller.signal.throwIfAborted();
+        const credential = await bounded(options.credential());
+        controller.signal.throwIfAborted();
+        if (!credential)
+            throw error(401, 'unauthenticated');
+        const response = await bounded(options.fetch(options.url, { method: write ? 'POST' : 'GET',
+            headers: { authorization: `Bearer ${credential}`, accept: 'application/json' },
+            redirect: 'error', cache: 'no-store', signal: controller.signal }).then(response => {
+            if (controller.signal.aborted) {
+                void response.body?.cancel().catch(() => { });
+                throw error(0, 'transport_error');
+            }
+            return response;
+        }));
+        if (!(response.status === 200 || write && response.status === 201)) {
+            void response.body?.cancel().catch(() => { });
+            throw error(response.status, 'enrollment_unconfirmed');
+        }
+        if (!response.body || !/^application\/json(?:;|$)/i.test(response.headers.get('content-type') ?? '')) {
+            void response.body?.cancel().catch(() => { });
+            throw error(0, 'invalid_response');
+        }
+        const reader = response.body.getReader(), chunks = [];
+        let size = 0;
+        const stop = () => { void reader.cancel().catch(() => { }); };
+        controller.signal.addEventListener('abort', stop, { once: true });
+        try {
+            for (;;) {
+                const next = await bounded(reader.read());
+                if (next.done)
+                    break;
+                size += next.value.length;
+                if (size > 8192)
+                    throw error(0, 'invalid_response');
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* cancelled read */ }
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw error(0, 'invalid_response');
+        }
+        const fields = ['state', 'organizationId', 'projectId', 'workspaceId', 'resourceEnvironment', ...(write ? ['created'] : [])];
+        if (!value || Array.isArray(value) || Object.keys(value).length !== fields.length || Object.keys(value).some(k => !fields.includes(k))
+            || !nativeId(value.organizationId, 'o_') || !nativeId(value.projectId, 'pr_') || !nativeId(value.workspaceId, 'w_')
+            || value.resourceEnvironment !== 'sandbox' || !['ready', ...(write ? [] : ['not_enrolled'])].includes(String(value.state))
+            || write && value.created !== (response.status === 201))
+            throw error(0, 'invalid_response');
+        return Response.json(value, { status: response.status, headers: { 'cache-control': 'no-store' } });
+    }
+    catch (e) {
+        if (e instanceof GenesisError)
+            throw e;
+        throw error(0, 'transport_error');
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function relaysEnrollment(client) {
+    return {
+        get: (options = {}) => client.request('relays_getEnrollment', {}, options),
+        activate: (options = {}) => client.request('relays_enroll', {}, options),
+    };
+}

package/dist/runner-grant.d.ts

@@ -0,0 +1,10 @@
+import { GenesisError } from './errors.js';
+import type { components } from './generated/schema.js';
+export type RunnerSelfExecutionGrantInput = components['schemas']['Iam.RunnerSelfExecutionGrantRequest'];
+export type RunnerSelfExecutionGrant = components['schemas']['Iam.RunnerSelfExecutionGrant'];
+export declare const RUNNER_SELF_GRANT_OPERATION: "iam_runnerSelfExecutionGrant";
+/** Copy only primitive data descriptors before any asynchronous credential call. */
+export declare function snapshotRunnerSelfGrant(args: Record<string, unknown>, routing: string): RunnerSelfExecutionGrantInput;
+export declare function runnerGrantTransportError(): GenesisError;
+/** A bounded closed response; no arbitrary upstream body reaches CLI or MCP. */
+export declare function runnerGrantResponse(res: Response, input: RunnerSelfExecutionGrantInput): Promise<Response>;