@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/cli/serve/index.js

@@ -0,0 +1,340 @@
+import path from 'node:path';
+import chokidar from 'chokidar';
+import { compileAll } from '../../builder/compile/compile-sequence.js';
+import { findTsModule } from '../../builder/paths.js';
+import { listSequenceIds, loadSequenceCaseContextView, loadSequenceFunctions } from '../../builder/load.js';
+import { createSourceComputeHost } from '../../compute-host/source-compute-host.js';
+import { encodeOverlayMessage, OVERLAY_REPLACED_CLOSE_CODE, parseOverlayMessage, } from '../../dev-overlay/protocol.js';
+const DEFAULT_BACKEND_URL = 'http://127.0.0.1:8100';
+function env(name) {
+    const value = process.env[name];
+    return value && value.length > 0 ? value : undefined;
+}
+export function overlayWebSocketUrl(raw) {
+    const url = new URL(raw);
+    if (url.protocol === 'http:')
+        url.protocol = 'ws:';
+    else if (url.protocol === 'https:')
+        url.protocol = 'wss:';
+    else if (url.protocol !== 'ws:' && url.protocol !== 'wss:') {
+        throw new Error(`unsupported backend url: ${raw}`);
+    }
+    const path = url.pathname.replace(/\/$/, '');
+    if (path === '')
+        url.pathname = '/overlay';
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
+/** `sequences/<id>/…` → sequence id */
+function sequenceIdFromPath(repoRoot, file) {
+    const rel = path.relative(repoRoot, file);
+    const match = /^sequences[/\\]([^/\\]+)(?:[/\\]|$)/.exec(rel);
+    return match?.[1] ?? null;
+}
+function isSchemaPath(repoRoot, file) {
+    const rel = path.relative(repoRoot, file);
+    return rel === 'schema.ts' || rel.startsWith(`schema${path.sep}`) || rel.startsWith('schema/');
+}
+async function loadOne(repoRoot, sequenceId, generation) {
+    const [compiled] = await compileAll(repoRoot, {
+        sequenceIds: [sequenceId],
+        dryRun: true,
+        includeCode: false,
+    });
+    if (!compiled) {
+        throw new Error(`Failed to compile sequence ${sequenceId}`);
+    }
+    const sequenceDir = path.join(repoRoot, 'sequences', sequenceId);
+    const functionsPath = findTsModule(sequenceDir, 'functions');
+    if (!functionsPath) {
+        throw new Error(`No functions module for sequence ${sequenceId}`);
+    }
+    const functions = await loadSequenceFunctions(functionsPath);
+    const viewPath = findTsModule(sequenceDir, 'view');
+    const view = viewPath ? await loadSequenceCaseContextView(viewPath) : undefined;
+    return { build: compiled.build, functions, view, generation };
+}
+async function loadSequences(repoRoot, sequenceIds, generation) {
+    const out = new Map();
+    for (const sequenceId of sequenceIds) {
+        out.set(sequenceId, await loadOne(repoRoot, sequenceId, generation));
+    }
+    return out;
+}
+function send(ws, message) {
+    ws.send(encodeOverlayMessage(message));
+}
+function logField(label, value) {
+    console.log(`  ${label.padEnd(10)} ${value}`);
+}
+async function handleExecute(loaded, message) {
+    const host = createSourceComputeHost({
+        functions: loaded.functions,
+        caseContextView: loaded.view,
+        data: message.data,
+        runToken: message.runToken,
+        getRequestId: () => message.logRequestId,
+    });
+    try {
+        return await host.execute(message.name, message.args);
+    }
+    finally {
+        host.dispose();
+    }
+}
+function pushOverlays(ws, sequences) {
+    for (const [sequenceId, loaded] of sequences) {
+        send(ws, {
+            type: 'overlay',
+            sequenceId,
+            generation: loaded.generation,
+            build: loaded.build,
+        });
+    }
+}
+function waitOpen(ws) {
+    return new Promise((resolve, reject) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            resolve();
+            return;
+        }
+        ws.addEventListener('open', () => resolve(), { once: true });
+        ws.addEventListener('error', () => reject(new Error('websocket error')), { once: true });
+    });
+}
+class OverlayReplacedError extends Error {
+    constructor() {
+        super('replaced by another serve');
+        this.name = 'OverlayReplacedError';
+    }
+}
+function waitAuthOk(ws) {
+    return new Promise((resolve, reject) => {
+        const onMessage = (event) => {
+            try {
+                const message = parseOverlayMessage(String(event.data));
+                if (message.type === 'auth.ok') {
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                if (message.type === 'replaced') {
+                    cleanup();
+                    reject(new OverlayReplacedError());
+                    return;
+                }
+                if (message.type === 'auth.error') {
+                    cleanup();
+                    reject(new Error(message.error));
+                }
+            }
+            catch (error) {
+                cleanup();
+                reject(error);
+            }
+        };
+        const onClose = (event) => {
+            cleanup();
+            reject(event.code === OVERLAY_REPLACED_CLOSE_CODE
+                ? new OverlayReplacedError()
+                : new Error('websocket closed before auth.ok'));
+        };
+        const cleanup = () => {
+            ws.removeEventListener('message', onMessage);
+            ws.removeEventListener('close', onClose);
+        };
+        ws.addEventListener('message', onMessage);
+        ws.addEventListener('close', onClose);
+    });
+}
+function attachExecuteHandler(ws, sequences) {
+    ws.addEventListener('message', (event) => {
+        void (async () => {
+            let message;
+            try {
+                message = parseOverlayMessage(String(event.data));
+            }
+            catch (error) {
+                console.error('bad server message:', error instanceof Error ? error.message : error);
+                return;
+            }
+            if (message.type !== 'execute')
+                return;
+            const call = `${message.sequenceId} ${message.name}`;
+            const loaded = sequences.get(message.sequenceId);
+            if (!loaded) {
+                const error = `unknown sequence ${message.sequenceId}`;
+                console.error(`execute ${call} failed: ${error}`);
+                send(ws, {
+                    type: 'execute.result',
+                    requestId: message.requestId,
+                    ok: false,
+                    error,
+                });
+                return;
+            }
+            const started = Date.now();
+            console.log(`execute ${call}`);
+            try {
+                const result = await handleExecute(loaded, message);
+                console.log(`execute ${call} ok ${Date.now() - started}ms`);
+                send(ws, { type: 'execute.result', requestId: message.requestId, ok: true, result });
+            }
+            catch (error) {
+                const text = error instanceof Error ? error.message : String(error);
+                console.error(`execute ${call} failed: ${text}`);
+                send(ws, {
+                    type: 'execute.result',
+                    requestId: message.requestId,
+                    ok: false,
+                    error: text,
+                });
+            }
+        })();
+    });
+}
+function waitSessionEnd(ws) {
+    return new Promise((resolve) => {
+        if (ws.readyState === WebSocket.CLOSED) {
+            resolve('closed');
+            return;
+        }
+        const onMessage = (event) => {
+            try {
+                const message = parseOverlayMessage(String(event.data));
+                if (message.type === 'replaced') {
+                    cleanup();
+                    resolve('replaced');
+                }
+            }
+            catch {
+                return;
+            }
+        };
+        const onClose = (event) => {
+            cleanup();
+            resolve(event.code === OVERLAY_REPLACED_CLOSE_CODE ? 'replaced' : 'closed');
+        };
+        const cleanup = () => {
+            ws.removeEventListener('message', onMessage);
+            ws.removeEventListener('close', onClose);
+        };
+        ws.addEventListener('message', onMessage);
+        ws.addEventListener('close', onClose);
+    });
+}
+export async function runServe(repoRoot, options = {}) {
+    const companyId = options.companyId ?? env('SUPERPANEL_SDK_COMPANY_ID');
+    const apiKey = options.apiKey ?? env('SUPERPANEL_SDK_API_KEY');
+    if (!companyId)
+        throw new Error('SUPERPANEL_SDK_COMPANY_ID or --company is required');
+    if (!apiKey)
+        throw new Error('SUPERPANEL_SDK_API_KEY or --api-key is required');
+    const backendUrl = options.url ?? env('SUPERPANEL_SDK_BACKEND_URL') ?? DEFAULT_BACKEND_URL;
+    const url = overlayWebSocketUrl(backendUrl);
+    const sequenceIds = options.sequenceIds ?? listSequenceIds(repoRoot);
+    if (sequenceIds.length === 0) {
+        throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')}`);
+    }
+    let generation = 1;
+    const sequences = await loadSequences(repoRoot, sequenceIds, generation);
+    let socket = null;
+    const names = [...sequences.keys()];
+    console.log('Local overlay');
+    logField('company', companyId);
+    logField('sequences', names.join(', '));
+    logField('backend', backendUrl);
+    logField('websocket', url);
+    let timer;
+    let pending = { all: false, ids: new Set() };
+    const flush = () => {
+        const job = pending;
+        pending = { all: false, ids: new Set() };
+        void (async () => {
+            try {
+                generation += 1;
+                const ids = job.all ? sequenceIds : [...job.ids];
+                if (job.all) {
+                    const next = await loadSequences(repoRoot, sequenceIds, generation);
+                    sequences.clear();
+                    for (const [id, loaded] of next)
+                        sequences.set(id, loaded);
+                }
+                else {
+                    for (const sequenceId of ids) {
+                        sequences.set(sequenceId, await loadOne(repoRoot, sequenceId, generation));
+                    }
+                }
+                if (socket && socket.readyState === WebSocket.OPEN) {
+                    pushOverlays(socket, sequences);
+                    console.log(`reloaded sequences ${ids.join(', ')}`);
+                }
+            }
+            catch (error) {
+                console.error('reload failed:', error instanceof Error ? error.message : error);
+            }
+        })();
+    };
+    chokidar
+        .watch([path.join(repoRoot, 'schema'), path.join(repoRoot, 'schema.ts'), path.join(repoRoot, 'sequences')], {
+        ignoreInitial: true,
+        ignored: (p) => p.includes(`${path.sep}__gen${path.sep}`) || p.includes(`${path.sep}build${path.sep}`),
+    })
+        .on('all', (event, file) => {
+        if (!file)
+            return;
+        if (file.includes(`${path.sep}__gen${path.sep}`))
+            return;
+        if (file.includes(`${path.sep}build${path.sep}`))
+            return;
+        const rel = path.relative(repoRoot, file);
+        const schemaHit = isSchemaPath(repoRoot, file);
+        const sequenceId = sequenceIdFromPath(repoRoot, file);
+        if (!schemaHit && !sequenceId)
+            return;
+        console.log(`changed ${rel}`);
+        if (schemaHit)
+            pending.all = true;
+        else if (sequenceId)
+            pending.ids.add(sequenceId);
+        clearTimeout(timer);
+        timer = setTimeout(flush, 100);
+    });
+    let delayMs = 500;
+    for (;;) {
+        const ws = new WebSocket(url);
+        socket = ws;
+        try {
+            await waitOpen(ws);
+            const authOk = waitAuthOk(ws);
+            send(ws, {
+                type: 'auth',
+                apiKey,
+                companyId,
+                names: [...sequences.keys()],
+            });
+            await authOk;
+            attachExecuteHandler(ws, sequences);
+            pushOverlays(ws, sequences);
+            delayMs = 500;
+            console.log(`connected  overlay ${url}`);
+            const end = await waitSessionEnd(ws);
+            if (end === 'replaced')
+                throw new OverlayReplacedError();
+            console.log('disconnected  retrying');
+        }
+        catch (error) {
+            if (error instanceof OverlayReplacedError)
+                throw error;
+            console.error('connection failed:', error instanceof Error ? error.message : error);
+            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+        }
+        socket = null;
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        delayMs = Math.min(delayMs * 2, 5_000);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/type-gen/index.d.ts

@@ -0,0 +1,5 @@
+export declare function runTypeGen(repoRoot: string, options: {
+    watchMode: boolean;
+    checkMode: boolean;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/type-gen/index.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import chokidar from 'chokidar';
+import { checkAll, generateAll, generateSequence, listSequenceIds } from '../../builder/codegen/generate.js';
+async function runOnce(repoRoot) {
+    const results = await generateAll(repoRoot);
+    for (const result of results) {
+        console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
+        console.log(`wrote ${path.relative(repoRoot, result.caseContextOutPath)}`);
+    }
+}
+/** `sequences/<id>/…` → sequence id */
+function sequenceIdFromPath(repoRoot, file) {
+    const rel = path.relative(repoRoot, file);
+    const match = /^sequences[/\\]([^/\\]+)(?:[/\\]|$)/.exec(rel);
+    return match?.[1] ?? null;
+}
+function isSchemaPath(repoRoot, file) {
+    const rel = path.relative(repoRoot, file);
+    return rel === 'schema.ts' || rel.startsWith(`schema${path.sep}`) || rel.startsWith('schema/');
+}
+async function runWatch(repoRoot) {
+    await runOnce(repoRoot);
+    console.log('[type:gen] watching schema/** and sequence sources');
+    console.log('[type:gen] sequences:', listSequenceIds(repoRoot).join(', ') || '(none)');
+    let timer;
+    let pending = {
+        all: false,
+        sequences: new Set(),
+    };
+    const flush = () => {
+        const job = pending;
+        pending = { all: false, sequences: new Set() };
+        void (async () => {
+            try {
+                if (job.all) {
+                    await runOnce(repoRoot);
+                    return;
+                }
+                for (const sequenceId of job.sequences) {
+                    const result = await generateSequence(repoRoot, sequenceId);
+                    console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
+                    console.log(`wrote ${path.relative(repoRoot, result.caseContextOutPath)}`);
+                }
+            }
+            catch (error) {
+                console.error('[type:gen] regenerate failed:', error instanceof Error ? error.message : error);
+            }
+        })();
+    };
+    chokidar
+        .watch([path.join(repoRoot, 'schema'), path.join(repoRoot, 'schema.ts'), path.join(repoRoot, 'sequences')], {
+        ignoreInitial: true,
+        ignored: (p) => p.includes(`${path.sep}__gen${path.sep}`) || p.includes(`${path.sep}build${path.sep}`),
+    })
+        .on('all', (event, file) => {
+        if (!file)
+            return;
+        if (file.includes(`${path.sep}__gen${path.sep}`))
+            return;
+        if (file.includes(`${path.sep}build${path.sep}`))
+            return;
+        const rel = path.relative(repoRoot, file);
+        const schemaHit = isSchemaPath(repoRoot, file);
+        const sequenceId = sequenceIdFromPath(repoRoot, file);
+        if (!schemaHit && !sequenceId)
+            return;
+        console.log(`[type:gen] ${event} ${rel}`);
+        if (schemaHit) {
+            pending.all = true;
+        }
+        else if (sequenceId) {
+            pending.sequences.add(sequenceId);
+        }
+        clearTimeout(timer);
+        timer = setTimeout(flush, 100);
+    });
+}
+export async function runTypeGen(repoRoot, options) {
+    if (options.checkMode) {
+        await checkAll(repoRoot);
+        console.log('Generated types are up to date.');
+        return;
+    }
+    if (options.watchMode) {
+        await runWatch(repoRoot);
+        return;
+    }
+    await runOnce(repoRoot);
+}
+//# sourceMappingURL=index.js.map

package/dist/compute-host/compute-host.d.ts

@@ -0,0 +1,38 @@
+import type { CaseContextViewFn } from '../core/functions/define/case-context.js';
+import type { RuntimeSlotsSnapshot } from '../core/slot/types.js';
+/**
+ * Pluggable host for sequence functions (derived / finishWhen / custom / system).
+ *
+ * - Local unit tests / company CI: {@link createLocalComputeHost} (direct JS call)
+ * - Author FuncMap: `createSourceComputeHost`
+ * - Platform backend: QuickJS / Cloudflare Worker hosts with the same `execute` surface
+ */
+export interface ComputeHost {
+    /**
+     * Invoke a registered function by name, then dispatch on `kind`.
+     * Compute/boolCompute/custom: `args[0]` is the raw snapshot (projected internally).
+     * `caseContextView`: `args[0]` is the raw snapshot (identity when the sequence has no view).
+     */
+    execute(name: string, args?: unknown[]): Promise<unknown>;
+    /** Release host-owned resources. No-op when the host has nothing to free. */
+    dispose(): void;
+}
+/**
+ * Name → computeFn. Parameter typed as `never` so company-narrowed
+ * `ComputeFn<CaseContext>` maps remain assignable (TS contravariance).
+ */
+export type ComputeFnMap = Record<string, (slots: never) => unknown | Promise<unknown>>;
+export type ComputeHostOrFns = ComputeHost | ComputeFnMap;
+export type LocalComputeHostOptions = {
+    /**
+     * Optional `(slots) => CaseContext` projector. Registered under the view.ts
+     * export name `caseContextView` and invoked before each compute fn
+     * (no cross-call cache — snapshot may change mid-recompute).
+     */
+    caseContextView?: CaseContextViewFn<RuntimeSlotsSnapshot, unknown>;
+};
+/** In-process host: call plain JS computeFns. No VM, no I/O fence. */
+export declare function createLocalComputeHost(fns: ComputeFnMap, options?: LocalComputeHostOptions): ComputeHost;
+/** Accept either a host or a name→fn map (map is wrapped as local host). */
+export declare function resolveComputeHost(hostOrFns: ComputeHostOrFns, options?: LocalComputeHostOptions): ComputeHost;
+//# sourceMappingURL=compute-host.d.ts.map

package/dist/compute-host/compute-host.js

@@ -0,0 +1,45 @@
+function isComputeHost(value) {
+    return typeof value.execute === 'function';
+}
+function requireSlots(name, args) {
+    const slots = args[0];
+    if (slots == null) {
+        throw new Error(`Function ${name}: args[0] (slots) required`);
+    }
+    return slots;
+}
+/** In-process host: call plain JS computeFns. No VM, no I/O fence. */
+export function createLocalComputeHost(fns, options = {}) {
+    if (Object.hasOwn(fns, 'caseContextView')) {
+        throw new Error(`computeFn name 'caseContextView' collides with the sequence view`);
+    }
+    const viewFn = options.caseContextView ?? ((slots) => slots);
+    const registry = {
+        caseContextView: { kind: 'caseContextView', main: viewFn },
+    };
+    for (const [name, fn] of Object.entries(fns)) {
+        registry[name] = { kind: 'compute', main: fn };
+    }
+    return {
+        async execute(name, args = []) {
+            const def = registry[name];
+            if (!def) {
+                throw new Error(`Missing computeFn implementation: ${name}`);
+            }
+            const snapshot = requireSlots(name, args);
+            if (def.kind === 'caseContextView') {
+                return def.main(snapshot);
+            }
+            return def.main(viewFn(snapshot));
+        },
+        dispose() { },
+    };
+}
+/** Accept either a host or a name→fn map (map is wrapped as local host). */
+export function resolveComputeHost(hostOrFns, options) {
+    if (isComputeHost(hostOrFns)) {
+        return hostOrFns;
+    }
+    return createLocalComputeHost(hostOrFns, options);
+}
+//# sourceMappingURL=compute-host.js.map

package/dist/compute-host/index.d.ts

@@ -0,0 +1,5 @@
+export { createLocalComputeHost, resolveComputeHost } from './compute-host.js';
+export type { ComputeFnMap, ComputeHost, ComputeHostOrFns, LocalComputeHostOptions } from './compute-host.js';
+export { createSourceComputeHost } from './source-compute-host.js';
+export type { SourceComputeHost, SourceComputeHostOptions } from './source-compute-host.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/compute-host/index.js

@@ -0,0 +1,3 @@
+export { createLocalComputeHost, resolveComputeHost } from './compute-host.js';
+export { createSourceComputeHost } from './source-compute-host.js';
+//# sourceMappingURL=index.js.map

package/dist/compute-host/source-compute-host.d.ts

@@ -0,0 +1,29 @@
+import { type CaseContextViewFn } from '../core/functions/define/case-context.js';
+import type { FuncMap } from '../core/functions/types.js';
+import type { ComputeHost } from './compute-host.js';
+import type { RuntimeSlotsSnapshot } from '../core/slot/types.js';
+import type { ActionDataSlice, ApiHost } from '../fn-context/types.js';
+export type SourceComputeHostOptions = {
+    functions: FuncMap;
+    caseContextView?: CaseContextViewFn<RuntimeSlotsSnapshot, unknown>;
+    /** Override ApiHost; default Fake, or Rpc when runToken + data.config.backendUrl. */
+    apiHost?: ApiHost;
+    /** ActionDataSlice used to build ctx for custom / system. */
+    data?: ActionDataSlice;
+    /** When set with data.config.backendUrl, uses Http RpcApiHost. */
+    runToken?: string;
+    /** Forwarded on every `ctx.api` RPC as `x-request-id`. */
+    getRequestId?: () => string | undefined;
+};
+export interface SourceComputeHost extends ComputeHost {
+}
+/**
+ * Local host: call author FuncMap implementations directly (no SequenceBuild.code).
+ *
+ * Lookup by name, then dispatch on `kind`:
+ * - caseContextView: `args[0]` is the raw snapshot (identity when no view).
+ * - compute / boolCompute / custom: `args[0]` is the raw snapshot (projected internally).
+ * - system: `args[0]` is the params object.
+ */
+export declare function createSourceComputeHost(options: SourceComputeHostOptions): SourceComputeHost;
+//# sourceMappingURL=source-compute-host.d.ts.map

package/dist/compute-host/source-compute-host.js

@@ -0,0 +1,72 @@
+import { resolveCaseContextViewFn } from '../core/functions/define/case-context.js';
+import { buildActionContext } from '../fn-context/build-context.js';
+import { createFakeApiHost } from '../fn-context/fake/index.js';
+import { createRpcApiHost } from '../fn-context/rpc/index.js';
+import { makeCtx } from '../fn-context/make-ctx.js';
+function requireSlots(name, args) {
+    const slots = args[0];
+    if (slots == null) {
+        throw new Error(`Function ${name}: args[0] (slots) required`);
+    }
+    return slots;
+}
+/**
+ * Local host: call author FuncMap implementations directly (no SequenceBuild.code).
+ *
+ * Lookup by name, then dispatch on `kind`:
+ * - caseContextView: `args[0]` is the raw snapshot (identity when no view).
+ * - compute / boolCompute / custom: `args[0]` is the raw snapshot (projected internally).
+ * - system: `args[0]` is the params object.
+ */
+export function createSourceComputeHost(options) {
+    const { functions, data } = options;
+    if (Object.hasOwn(functions, 'caseContextView')) {
+        throw new Error(`functions map already has 'caseContextView'; that name is the sequence view`);
+    }
+    const apiHost = resolveApiHost(options);
+    const viewFn = resolveCaseContextViewFn(options.caseContextView) ?? ((slots) => slots);
+    const registry = {
+        ...functions,
+        caseContextView: { kind: 'caseContextView', main: viewFn },
+    };
+    async function systemContext() {
+        return data ? buildActionContext(data, apiHost) : makeCtx();
+    }
+    return {
+        async execute(name, args = []) {
+            const def = registry[name];
+            if (!def) {
+                throw new Error(`Missing function: ${name}`);
+            }
+            if (def.kind === 'caseContextView') {
+                return def.main(requireSlots(name, args));
+            }
+            if (def.kind === 'compute' || def.kind === 'boolCompute') {
+                return def.main(viewFn(requireSlots(name, args)));
+            }
+            if (def.kind === 'custom') {
+                const caseContext = viewFn(requireSlots(name, args));
+                const ctx = await systemContext();
+                const fn = def.main;
+                return fn(caseContext, ctx);
+            }
+            const params = (args[0] ?? {});
+            const ctx = await systemContext();
+            return def.main({ ...ctx, params });
+        },
+        dispose() { },
+    };
+}
+function resolveApiHost(options) {
+    if (options.apiHost)
+        return options.apiHost;
+    if (options.runToken && options.data?.config.backendUrl) {
+        return createRpcApiHost({
+            baseUrl: options.data.config.backendUrl,
+            getToken: () => options.runToken,
+            getRequestId: options.getRequestId,
+        });
+    }
+    return createFakeApiHost();
+}
+//# sourceMappingURL=source-compute-host.js.map

package/dist/core/context/account-fields.d.ts

@@ -0,0 +1,12 @@
+export type IntegrationTarget = {
+    kind: 'account' | 'resource';
+    id: string;
+};
+/** Identity fields every script-facing integration stub carries. */
+export type IntegrationAccountFields = {
+    readonly target: IntegrationTarget;
+    readonly name: string;
+    readonly credentials: Record<string, unknown>;
+    readonly config: Record<string, unknown>;
+};
+//# sourceMappingURL=account-fields.d.ts.map

package/dist/core/context/account-fields.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=account-fields.js.map