@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/foundry-billing.js

@@ -0,0 +1,107 @@
+import { errorOutcome, errorToken, GenesisError } from './errors.js';
+export const foundryBillingOperations = ['foundry_readBillingProfile', 'foundry_ensureBillingProfile', 'foundry_createNativeCreditCheckout', 'foundry_readNativeCreditBalance'];
+export const isFoundryBillingOperation = (id) => foundryBillingOperations.includes(id);
+const writes = new Set(['foundry_ensureBillingProfile', 'foundry_createNativeCreditCheckout']);
+const keyValid = (key) => typeof key === 'string' && /^[\x21-\x7e]{1,255}(?![\s\S])/.test(key) && !key.includes(',');
+/** One gateway dispatch, no redirect or automatic retry. Native billing always
+ * uses the caller's original human credential; customer/provider selectors are absent. */
+export async function foundryBillingTransport(options) {
+    const write = writes.has(options.operationId), key = options.headers?.['idempotency-key'];
+    const error = (status, type, body) => new GenesisError({ status, type, body, operationId: options.operationId,
+        message: 'Native Foundry billing was not confirmed. Preserve the operation key and reconcile an unknown result before retrying.' });
+    const body = options.input.body;
+    if (options.routing !== 'gateway' || !isFoundryBillingOperation(options.operationId) || Object.keys(options.input).some(k => k !== 'body')
+        || (write ? !keyValid(key) || !body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).length > 0 : Object.keys(options.input).length > 0))
+        throw error(0, 'invalid_request');
+    const controller = new AbortController(), cancel = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        cancel();
+    else
+        options.signal?.addEventListener('abort', cancel, { once: true });
+    const timer = setTimeout(() => controller.abort(), 20_000);
+    async function bounded(work) {
+        controller.signal.throwIfAborted();
+        let abort = () => { };
+        try {
+            return await Promise.race([work, new Promise((_, reject) => { abort = () => reject(error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined)); 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', ...(write ? { 'content-type': 'application/json', 'idempotency-key': key } : {}) },
+            ...(write ? { body: '{}' } : {}), signal: controller.signal, redirect: 'error', cache: 'no-store' }).then(response => { if (controller.signal.aborted) {
+            void response.body?.cancel().catch(() => { });
+            throw error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined);
+        } return response; }));
+        if (!response.body || !/^application\/json(?:;|$)/i.test(response.headers.get('content-type') ?? ''))
+            throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+        const reader = response.body.getReader(), parts = [];
+        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 > 16384)
+                    throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+                parts.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* pending read was cancelled */ }
+        }
+        const bytes = new Uint8Array(size);
+        let at = 0;
+        for (const part of parts) {
+            bytes.set(part, at);
+            at += part.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw error(response.status, 'invalid_response', write ? { outcome: 'unknown' } : undefined);
+        }
+        if (!response.ok) {
+            const fields = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+            // Envelope (error.code / error.outcome) or legacy string form; only an explicit not_dispatched 400 is safe to fix and resend.
+            const outcome = response.status === 400 && errorToken(fields) === 'invalid_billing_request' && errorOutcome(fields) === 'not_dispatched' ? 'not_dispatched' : 'unknown';
+            throw error(response.status, 'billing_unconfirmed', write ? { ...fields, outcome } : value);
+        }
+        return Response.json(value, { status: response.status, headers: { 'cache-control': 'no-store' } });
+    }
+    catch (e) {
+        if (e instanceof GenesisError)
+            throw e;
+        throw error(0, 'outcome_unknown', write ? { outcome: 'unknown' } : undefined);
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function foundryBilling(client) {
+    const read = (id, options = {}) => client.request(id, {}, options);
+    const write = (id, key, options = {}) => client.request(id, { body: {} }, { ...options, headers: { 'idempotency-key': key } });
+    return { profile: (options) => read('foundry_readBillingProfile', options),
+        ensureProfile: (operationKey, options) => write('foundry_ensureBillingProfile', operationKey, options),
+        checkoutCredits: (purchaseKey, options) => write('foundry_createNativeCreditCheckout', purchaseKey, options),
+        creditBalance: (options) => read('foundry_readNativeCreditBalance', options) };
+}

package/dist/gears.d.ts

@@ -0,0 +1,107 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Gears durable workflows: exactly the gateway-admitted reads, register, start and signal.
+ * Writes take an optional idempotency key; with one, a retry returns the original result. */
+export declare function gearsModule(client: GenesisClient): {
+    workflows: {
+        list: () => Promise<{
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            name: string;
+            definitionRef: string;
+            registeredBy: string;
+        }[]>;
+        get: (id: string) => Promise<{
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            name: string;
+            definitionRef: string;
+            registeredBy: string;
+        }>;
+        register: (body: In<"gears_registerWorkflow">["body"], idempotencyKey?: string) => Promise<{
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            name: string;
+            definitionRef: string;
+            registeredBy: string;
+        }>;
+    };
+    runs: {
+        list: () => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }[]>;
+        get: (id: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        history: (id: string) => Promise<{
+            sequence: number;
+            runId: string;
+            kind: string;
+            actorId?: string;
+            detailRef?: string | null;
+        }[]>;
+        start: (body: In<"gears_startRun">["body"], idempotencyKey?: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        signal: (id: string, body: In<"gears_signalRun">["body"], idempotencyKey?: string) => Promise<Record<string, never>>;
+    };
+    records: () => Promise<{
+        meterRecords?: {
+            product?: string;
+            gardenMeter?: string;
+            quantity?: number;
+            scopeKey?: string;
+        }[];
+        auditRecords?: {
+            product?: string;
+            auditAction?: string;
+            actorId?: string;
+            targetRef?: string;
+        }[];
+        evidenceRecords?: {
+            product?: string;
+            evidenceRef?: string;
+            evidenceKind?: string;
+        }[];
+        replayEvidence?: {
+            product?: string;
+            replayEngine?: string;
+            runId?: string;
+            journalSequence?: number;
+            evidenceRef?: string;
+        }[];
+        probeEvents?: {
+            product?: string;
+            eventType?: string;
+            actorId?: string;
+            targetRef?: string;
+        }[];
+    }>;
+};

package/dist/gears.js

@@ -0,0 +1,20 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Gears durable workflows: exactly the gateway-admitted reads, register, start and signal.
+ * Writes take an optional idempotency key; with one, a retry returns the original result. */
+export function gearsModule(client) {
+    return {
+        workflows: {
+            list: () => client.request('gears_listWorkflows'),
+            get: (id) => client.request('gears_getWorkflow', { id }),
+            register: async (body, idempotencyKey) => client.request('gears_registerWorkflow', { body }, { headers: idempotencyHeaders('gears_registerWorkflow', idempotencyKey) }),
+        },
+        runs: {
+            list: () => client.request('gears_listRuns'),
+            get: (id) => client.request('gears_getRun', { id }),
+            history: (id) => client.request('gears_getRunHistory', { id }),
+            start: async (body, idempotencyKey) => client.request('gears_startRun', { body }, { headers: idempotencyHeaders('gears_startRun', idempotencyKey) }),
+            signal: async (id, body, idempotencyKey) => client.request('gears_signalRun', { id, body }, { headers: idempotencyHeaders('gears_signalRun', idempotencyKey) }),
+        },
+        records: () => client.request('gears_listOperationalRecords'),
+    };
+}