@superpanel-sdk/runtime 0.2.0 → 0.2.2

package/dist/builder/codegen/generate.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { withCompanyImportGraph } from '../company-import-graph.js';
 import { listSequenceIds, loadCompanySchema, loadSequenceSlots } from '../load.js';
 import { mergeEffectiveSchema } from '../merge.js';
 import { findTsModule, resolveTsModule } from '../paths.js';
@@ -12,6 +13,9 @@ function sequenceCaseContextGenPath(repoRoot, sequenceId) {
     return path.join(repoRoot, 'sequences', sequenceId, '__gen', 'case-context.type.ts');
 }
 export async function generateSequence(repoRoot, sequenceId, options = {}) {
+    return withCompanyImportGraph(repoRoot, () => generateSequenceInGraph(repoRoot, sequenceId, options));
+}
+async function generateSequenceInGraph(repoRoot, sequenceId, options) {
     const schemaPath = resolveTsModule(repoRoot, 'schema', `No company schema found. Expected schema.ts or schema/index.ts under ${repoRoot}`);
     const slotsPath = resolveTsModule(path.join(repoRoot, 'sequences', sequenceId), 'slots', `No sequence slots found. Expected sequences/${sequenceId}/slots.ts or sequences/${sequenceId}/slots/index.ts`);
     const company = await loadCompanySchema(schemaPath);
@@ -38,15 +42,17 @@ export async function generateSequence(repoRoot, sequenceId, options = {}) {
     };
 }
 export async function generateAll(repoRoot, options = {}) {
-    const ids = options.sequenceIds ?? listSequenceIds(repoRoot);
-    if (ids.length === 0) {
-        throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')} (expected slots.ts or slots/index.ts)`);
-    }
-    const results = [];
-    for (const sequenceId of ids) {
-        results.push(await generateSequence(repoRoot, sequenceId, options));
-    }
-    return results;
+    return withCompanyImportGraph(repoRoot, async () => {
+        const ids = options.sequenceIds ?? listSequenceIds(repoRoot);
+        if (ids.length === 0) {
+            throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')} (expected slots.ts or slots/index.ts)`);
+        }
+        const results = [];
+        for (const sequenceId of ids) {
+            results.push(await generateSequence(repoRoot, sequenceId, options));
+        }
+        return results;
+    });
 }
 function assertFileMatches(outPath, next, repoRoot) {
     let current = '';

package/dist/builder/company-import-graph.d.ts

@@ -0,0 +1,11 @@
+/** Stamp a company-repo entry URL, or return it unchanged outside a graph. */
+export declare function companyImportGraphHref(fileHref: string): string;
+/**
+ * Load company-repo modules as one ESM graph.
+ *
+ * Nested calls (same async context) reuse the graph so compile + overlay
+ * `loadSequenceFunctions` share object identity. Overlapping outer calls wait
+ * their turn, then bump generation so watch sees new source.
+ */
+export declare function withCompanyImportGraph<T>(repoRoot: string, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=company-import-graph.d.ts.map

package/dist/builder/company-import-graph.js

@@ -0,0 +1,105 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { realpathSync } from 'node:fs';
+import { registerHooks } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const COMPANY_GRAPH_GEN_QUERY = 'spgen';
+const COMPANY_GRAPH_ROOT_QUERY = 'sproot';
+const graph = new AsyncLocalStorage();
+let generation = 0;
+let registered = false;
+let outerTail = Promise.resolve();
+function filePathFromUrl(url) {
+    const parsed = new URL(url);
+    parsed.search = '';
+    parsed.hash = '';
+    return fileURLToPath(parsed);
+}
+function realPath(filePath) {
+    try {
+        return realpathSync(filePath);
+    }
+    catch {
+        return path.resolve(filePath);
+    }
+}
+function underRoot(filePath, root) {
+    const resolved = realPath(filePath);
+    const base = realPath(root);
+    return resolved === base || resolved.startsWith(`${base}${path.sep}`);
+}
+function inNodeModules(filePath, url) {
+    return (url.includes('/node_modules/') ||
+        url.includes('\\node_modules\\') ||
+        filePath.includes(`${path.sep}node_modules${path.sep}`));
+}
+function stampCompanyResolve(specifier, context, nextResolve) {
+    const result = nextResolve(specifier, context);
+    if (!result.url.startsWith('file:'))
+        return result;
+    const resolved = new URL(result.url);
+    if (resolved.searchParams.has(COMPANY_GRAPH_GEN_QUERY))
+        return result;
+    const parent = context.parentURL ? new URL(context.parentURL) : null;
+    const graphGeneration = parent?.searchParams.get(COMPANY_GRAPH_GEN_QUERY);
+    const repoRoot = parent?.searchParams.get(COMPANY_GRAPH_ROOT_QUERY);
+    if (!graphGeneration || !repoRoot)
+        return result;
+    let resolvedFile;
+    try {
+        resolvedFile = filePathFromUrl(result.url);
+    }
+    catch {
+        return result;
+    }
+    if (inNodeModules(resolvedFile, result.url))
+        return result;
+    if (!underRoot(resolvedFile, repoRoot))
+        return result;
+    resolved.searchParams.set(COMPANY_GRAPH_GEN_QUERY, graphGeneration);
+    resolved.searchParams.set(COMPANY_GRAPH_ROOT_QUERY, repoRoot);
+    return { ...result, url: resolved.href };
+}
+function ensureHookRegistered() {
+    if (registered)
+        return;
+    registered = true;
+    registerHooks({ resolve: stampCompanyResolve });
+}
+/** Stamp a company-repo entry URL, or return it unchanged outside a graph. */
+export function companyImportGraphHref(fileHref) {
+    const store = graph.getStore();
+    if (!store)
+        return fileHref;
+    const url = new URL(fileHref);
+    url.searchParams.set(COMPANY_GRAPH_GEN_QUERY, String(store.generation));
+    url.searchParams.set(COMPANY_GRAPH_ROOT_QUERY, store.repoRoot);
+    return url.href;
+}
+/**
+ * Load company-repo modules as one ESM graph.
+ *
+ * Nested calls (same async context) reuse the graph so compile + overlay
+ * `loadSequenceFunctions` share object identity. Overlapping outer calls wait
+ * their turn, then bump generation so watch sees new source.
+ */
+export async function withCompanyImportGraph(repoRoot, fn) {
+    ensureHookRegistered();
+    if (graph.getStore())
+        return fn();
+    const root = realpathSync(path.resolve(repoRoot));
+    let release;
+    const previous = outerTail;
+    outerTail = new Promise((resolve) => {
+        release = resolve;
+    });
+    await previous;
+    generation += 1;
+    try {
+        return await graph.run({ generation, repoRoot: root }, fn);
+    }
+    finally {
+        release();
+    }
+}
+//# sourceMappingURL=company-import-graph.js.map

package/dist/builder/compile/compile-sequence.d.ts

@@ -1,8 +1,9 @@
 import type { FuncMap } from '../../core/functions/types.js';
 import type { CompanySchema } from '../../core/slot/schema.js';
-import type { SequenceBuild } from '../types.js';
+import type { RuntimePackageSource, SequenceBuild } from '../types.js';
 /** SequenceBuild / SequenceConfigBuild cache key. Bump when compiled `code` shape changes. */
 export declare function runtimePackageVersion(): string;
+export declare function runtimePackageSource(repoRoot: string): RuntimePackageSource;
 /** Deep-clone company schema with derived computeFn normalized to string names. */
 export declare function snapshotCompanySchema(company: CompanySchema, functions?: FuncMap): CompanySchema;
 export declare function sequenceBuildPath(repoRoot: string, sequenceId: string): string;
@@ -12,6 +13,8 @@ export type CompileSequenceOptions = {
     includeCode?: boolean;
     /** Persist on SequenceBuild.sha. Defaults to `local`. */
     sha?: string;
+    /** Dependency source captured before deployment rewrites package.json. */
+    runtimeSource?: RuntimePackageSource;
 };
 export type CompileSequenceResult = {
     sequenceId: string;

package/dist/builder/compile/compile-sequence.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { resolveCaseContextViewFn } from '../../core/functions/define/case-context.js';
 import { resolveFuncName } from '../../core/functions/func-ref.js';
 import { compileSlotSchema } from '../../core/slot/compile-schema.js';
+import { withCompanyImportGraph } from '../company-import-graph.js';
 import { listSequenceIds, loadCompanySchema, loadSequenceAgendas, loadSequenceCaseContextView, loadSequenceFunctions, loadSequenceSlots, } from '../load.js';
 import { findTsModule, resolveTsModule } from '../paths.js';
 import { compileSequenceAgendas, fatalAgendaIssues } from './compile-agenda.js';
@@ -27,6 +28,18 @@ export function runtimePackageVersion() {
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
     return pkg.version ?? '0.0.0';
 }
+export function runtimePackageSource(repoRoot) {
+    try {
+        const pkg = JSON.parse(readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+        const spec = pkg.dependencies?.['@superpanel-sdk/runtime'] ??
+            pkg.devDependencies?.['@superpanel-sdk/runtime'] ??
+            pkg.optionalDependencies?.['@superpanel-sdk/runtime'];
+        return spec?.startsWith('file:') || spec?.startsWith('workspace:') ? 'local-file' : 'npm';
+    }
+    catch {
+        return 'npm';
+    }
+}
 /** Deep-clone company schema with derived computeFn normalized to string names. */
 export function snapshotCompanySchema(company, functions) {
     const tables = {};
@@ -51,6 +64,9 @@ export function sequenceBuildPath(repoRoot, sequenceId) {
     return path.join(repoRoot, 'sequences', sequenceId, 'build', 'sequence-build.json');
 }
 export async function compileSequence(repoRoot, sequenceId, options = {}) {
+    return withCompanyImportGraph(repoRoot, () => compileSequenceInGraph(repoRoot, sequenceId, options));
+}
+async function compileSequenceInGraph(repoRoot, sequenceId, options) {
     const schemaPath = resolveTsModule(repoRoot, 'schema', `No company schema found. Expected schema.ts or schema/index.ts under ${repoRoot}`);
     const sequenceDir = path.join(repoRoot, 'sequences', sequenceId);
     const slotsPath = resolveTsModule(sequenceDir, 'slots', `No sequence slots found. Expected sequences/${sequenceId}/slots.ts or sequences/${sequenceId}/slots/index.ts`);
@@ -92,6 +108,7 @@ export async function compileSequence(repoRoot, sequenceId, options = {}) {
         sequenceId,
         sha: options.sha ?? 'local',
         engineVersion: runtimePackageVersion(),
+        runtimeSource: options.runtimeSource ?? runtimePackageSource(repoRoot),
         compiledAt: new Date().toISOString(),
         companySchemaSnapshot: snapshotCompanySchema(company, functions),
         schema: compiledAgendas.schema,
@@ -108,14 +125,16 @@ export async function compileSequence(repoRoot, sequenceId, options = {}) {
     return { sequenceId, outPath, build, wrote: !options.dryRun };
 }
 export async function compileAll(repoRoot, options = {}) {
-    const ids = options.sequenceIds ?? listSequenceIds(repoRoot);
-    if (ids.length === 0) {
-        throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')} (expected slots.ts or slots/index.ts)`);
-    }
-    const results = [];
-    for (const sequenceId of ids) {
-        results.push(await compileSequence(repoRoot, sequenceId, options));
-    }
-    return results;
+    return withCompanyImportGraph(repoRoot, async () => {
+        const ids = options.sequenceIds ?? listSequenceIds(repoRoot);
+        if (ids.length === 0) {
+            throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')} (expected slots.ts or slots/index.ts)`);
+        }
+        const results = [];
+        for (const sequenceId of ids) {
+            results.push(await compileSequence(repoRoot, sequenceId, options));
+        }
+        return results;
+    });
 }
 //# sourceMappingURL=compile-sequence.js.map

package/dist/builder/load.js

@@ -3,11 +3,11 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { resolveCaseContextViewFn } from '../core/functions/define/case-context.js';
 import { isAgendaTree, isSequenceAgendas } from '../core/stage/flatten.js';
+import { companyImportGraphHref } from './company-import-graph.js';
 import { findTsModule } from './paths.js';
 async function importModule(filePath) {
-    const href = pathToFileURL(filePath).href;
-    // Cache-bust so --watch reloads edited TS modules.
-    const mod = await import(`${href}?t=${Date.now()}`);
+    const href = companyImportGraphHref(pathToFileURL(filePath).href);
+    const mod = await import(href);
     return mod;
 }
 function isFuncMap(value) {

package/dist/builder/types.d.ts

@@ -2,6 +2,7 @@ import type { CaseContextViewRegistryEntry, FunctionRegistry } from '../core/fun
 import type { CompanySchema, EffectiveSchema } from '../core/slot/schema.js';
 import type { CompiledSlotSchema } from '../core/slot/types.js';
 import type { CompiledAgenda } from '../core/stage/types.js';
+export type RuntimePackageSource = 'local-file' | 'npm';
 /**
  * Compiled sequence artifact (Manual §9 subset; grows over time).
  * Omitted for now: paramsDefaults, schedulers, caseManual.
@@ -13,6 +14,10 @@ export type SequenceBuild = {
     sequenceId: string;
     sha: string;
     engineVersion: string;
+    /** Installed @superpanel-sdk/runtime version resolved from the company repo. */
+    runtimeVersion?: string;
+    /** Dependency source declared by the company repo. Optional for legacy persisted builds. */
+    runtimeSource?: RuntimePackageSource;
     compiledAt: string;
     companySchemaSnapshot: CompanySchema;
     /** SlotEngine runtime schema (tables + derivedOrder / reverseDeps). */

package/dist/cli/serve/index.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import chokidar from 'chokidar';
 import { compileAll } from '../../builder/compile/compile-sequence.js';
+import { withCompanyImportGraph } from '../../builder/company-import-graph.js';
 import { findTsModule } from '../../builder/paths.js';
 import { listSequenceIds, loadSequenceCaseContextView, loadSequenceFunctions } from '../../builder/load.js';
 import { createSourceComputeHost } from '../../compute-host/source-compute-host.js';
@@ -37,30 +38,34 @@ function isSchemaPath(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,
+    return withCompanyImportGraph(repoRoot, async () => {
+        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 };
     });
-    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;
+    return withCompanyImportGraph(repoRoot, async () => {
+        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));
@@ -74,7 +79,10 @@ async function handleExecute(loaded, message) {
         caseContextView: loaded.view,
         data: message.data,
         runToken: message.runToken,
+        runtimeVersion: loaded.build.runtimeVersion ?? loaded.build.engineVersion,
+        runtimeSource: loaded.build.runtimeSource ?? 'npm',
         getRequestId: () => message.logRequestId,
+        getTags: () => message.logTags,
     });
     try {
         return await host.execute(message.name, message.args);
@@ -248,32 +256,37 @@ export async function runServe(repoRoot, options = {}) {
     logField('websocket', url);
     let timer;
     let pending = { all: false, ids: new Set() };
+    let flushing = false;
     const flush = () => {
-        const job = pending;
-        pending = { all: false, ids: new Set() };
+        if (flushing)
+            return;
+        flushing = true;
         void (async () => {
             try {
-                generation += 1;
-                const ids = job.all ? sequenceIds : [...job.ids];
-                if (job.all) {
-                    const next = await loadSequences(repoRoot, sequenceIds, generation);
-                    sequences.clear();
+                while (pending.all || pending.ids.size > 0) {
+                    const job = pending;
+                    pending = { all: false, ids: new Set() };
+                    generation += 1;
+                    const ids = job.all ? sequenceIds : [...job.ids];
+                    const next = await loadSequences(repoRoot, ids, generation);
+                    if (job.all)
+                        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(', ')}`);
                     }
                 }
-                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);
             }
+            finally {
+                flushing = false;
+                if (pending.all || pending.ids.size > 0)
+                    flush();
+            }
         })();
     };
     chokidar

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

@@ -12,8 +12,14 @@ export type SourceComputeHostOptions = {
     data?: ActionDataSlice;
     /** When set with data.config.backendUrl, uses Http RpcApiHost. */
     runToken?: string;
+    /** Runtime version forwarded on every `ctx.api` RPC. Required when RpcApiHost is used. */
+    runtimeVersion?: string;
+    /** Runtime dependency source forwarded with runtimeVersion. Required when RpcApiHost is used. */
+    runtimeSource?: 'local-file' | 'npm';
     /** Forwarded on every `ctx.api` RPC as `x-request-id`. */
     getRequestId?: () => string | undefined;
+    /** Forwarded to script log RPC calls. */
+    getTags?: () => string[] | undefined;
 };
 export interface SourceComputeHost extends ComputeHost {
 }

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

@@ -62,10 +62,16 @@ function resolveApiHost(options) {
     if (options.apiHost)
         return options.apiHost;
     if (options.runToken && options.data?.config.backendUrl) {
+        if (!options.runtimeVersion || !options.runtimeSource) {
+            throw new Error('runtimeVersion and runtimeSource are required when using RpcApiHost');
+        }
         return createRpcApiHost({
             baseUrl: options.data.config.backendUrl,
             getToken: () => options.runToken,
+            runtimeVersion: options.runtimeVersion,
+            runtimeSource: options.runtimeSource,
             getRequestId: options.getRequestId,
+            getTags: options.getTags,
         });
     }
     return createFakeApiHost();

package/dist/dev-overlay/protocol.d.ts

@@ -33,6 +33,8 @@ export type OverlayExecuteMessage = {
     runToken?: string;
     /** Logger request id for `ctx.api` RPC; not the overlay execute correlation id. */
     logRequestId?: string;
+    /** Logger tags inherited from the backend execution context. */
+    logTags?: string[];
 };
 export type OverlayExecuteResultMessage = {
     type: 'execute.result';

package/dist/fn-context/index.d.ts

@@ -3,7 +3,7 @@ export { buildActionContext, type BuildActionContextOptions } from './build-cont
 export { resolveSystemFnParams } from './system-args.js';
 export { createFakeApiHost, type FakeApiHostOptions } from './fake/index.js';
 export { defaultPlatformApis, emptyIntegration, type PlatformApiOverrides } from './fake/empty-api.js';
-export { createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader } from './rpc/index.js';
+export { createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './rpc/index.js';
 export { bindLogMeta, noopLog } from './log.js';
 export { makeCtx, makeCtxAsync } from './make-ctx.js';
 export { defaultHttpApi } from '../core/context/http.js';

package/dist/fn-context/index.js

@@ -2,7 +2,7 @@ export { buildActionContext } from './build-context.js';
 export { resolveSystemFnParams } from './system-args.js';
 export { createFakeApiHost } from './fake/index.js';
 export { defaultPlatformApis, emptyIntegration } from './fake/empty-api.js';
-export { createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader } from './rpc/index.js';
+export { createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './rpc/index.js';
 export { bindLogMeta, noopLog } from './log.js';
 export { makeCtx, makeCtxAsync } from './make-ctx.js';
 export { defaultHttpApi } from '../core/context/http.js';

package/dist/fn-context/rpc/index.d.ts

@@ -6,5 +6,5 @@ export { createListBindingsProcedure } from './integration/list-bindings.js';
 export { createPlatformRouter, type PlatformInvokeHandler } from './platform.js';
 export { createLogRouter, type LogEmitHandler } from './log.js';
 export { createRpcApiHost } from './trpc-client.js';
-export { REQUEST_ID_HEADER, readRequestIdHeader } from './request-id.js';
+export { LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './request-id.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fn-context/rpc/index.js

@@ -5,5 +5,5 @@ export { createListBindingsProcedure } from './integration/list-bindings.js';
 export { createPlatformRouter } from './platform.js';
 export { createLogRouter } from './log.js';
 export { createRpcApiHost } from './trpc-client.js';
-export { REQUEST_ID_HEADER, readRequestIdHeader } from './request-id.js';
+export { LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './request-id.js';
 //# sourceMappingURL=index.js.map

package/dist/fn-context/rpc/log.d.ts

@@ -8,11 +8,13 @@ export declare const logEmitInput: z.ZodObject<{
     }>;
     message: z.ZodString;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type LogEmitHandler = (input: {
     level: 'info' | 'warn' | 'error';
     message: string;
     extra?: Record<string, unknown>;
+    tags?: string[];
     ctx: RpcContext;
 }) => Promise<void>;
 export declare function createLogRouter(emit: LogEmitHandler): import("@trpc/server").TRPCBuiltRouter<{
@@ -26,6 +28,7 @@ export declare function createLogRouter(emit: LogEmitHandler): import("@trpc/ser
             level: "error" | "info" | "warn";
             message: string;
             extra?: Record<string, unknown> | undefined;
+            tags?: string[] | undefined;
         };
         output: {
             ok: true;

package/dist/fn-context/rpc/log.js

@@ -4,11 +4,12 @@ export const logEmitInput = z.object({
     level: z.enum(['info', 'warn', 'error']),
     message: z.string(),
     extra: z.record(z.string(), z.unknown()).optional(),
+    tags: z.array(z.string()).optional(),
 });
 export function createLogRouter(emit) {
     return router({
         emit: publicProcedure.input(logEmitInput).mutation(async ({ ctx, input }) => {
-            await emit({ level: input.level, message: input.message, extra: input.extra, ctx });
+            await emit({ level: input.level, message: input.message, extra: input.extra, tags: input.tags, ctx });
             return { ok: true };
         }),
     });

package/dist/fn-context/rpc/request-id.d.ts

@@ -1,5 +1,15 @@
 export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare const LOG_TAGS_HEADER = "x-superpanel-log-tags";
+export declare const RUNTIME_VERSION_HEADER = "x-superpanel-runtime-version";
+export declare function formatRuntimeVersion(version: string, source: 'local-file' | 'npm'): string;
 export declare function readRequestIdHeader(headers: {
     get(name: string): string | null;
 } | Record<string, string | string[] | undefined>): string | undefined;
+export declare function readRuntimeVersionHeader(headers: {
+    get(name: string): string | null;
+} | Record<string, string | string[] | undefined>): string | undefined;
+export declare function encodeLogTagsHeader(tags: string[]): string;
+export declare function readLogTagsHeader(headers: {
+    get(name: string): string | null;
+}): string[] | undefined;
 //# sourceMappingURL=request-id.d.ts.map

package/dist/fn-context/rpc/request-id.js

@@ -1,4 +1,9 @@
 export const REQUEST_ID_HEADER = 'x-request-id';
+export const LOG_TAGS_HEADER = 'x-superpanel-log-tags';
+export const RUNTIME_VERSION_HEADER = 'x-superpanel-runtime-version';
+export function formatRuntimeVersion(version, source) {
+    return `${version}-${source}`;
+}
 function firstString(value) {
     const raw = Array.isArray(value) ? value[0] : value;
     return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
@@ -10,4 +15,28 @@ export function readRequestIdHeader(headers) {
     const record = headers;
     return firstString(record[REQUEST_ID_HEADER]);
 }
+export function readRuntimeVersionHeader(headers) {
+    if (typeof headers.get === 'function') {
+        return firstString(headers.get(RUNTIME_VERSION_HEADER));
+    }
+    const record = headers;
+    return firstString(record[RUNTIME_VERSION_HEADER]);
+}
+export function encodeLogTagsHeader(tags) {
+    return JSON.stringify(tags);
+}
+export function readLogTagsHeader(headers) {
+    const raw = headers.get(LOG_TAGS_HEADER);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || !parsed.every((tag) => typeof tag === 'string'))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=request-id.js.map

package/dist/fn-context/rpc/trpc-client.d.ts

@@ -2,6 +2,10 @@ import type { ApiHost } from '../types.js';
 export declare function createRpcApiHost(options: {
     baseUrl: string;
     getToken: () => string | Promise<string>;
+    runtimeVersion: string;
+    runtimeSource: 'local-file' | 'npm';
     getRequestId?: () => string | undefined;
+    getTags?: () => string[] | undefined;
+    waitUntil?: (promise: Promise<unknown>) => void;
 }): ApiHost;
 //# sourceMappingURL=trpc-client.d.ts.map

package/dist/fn-context/rpc/trpc-client.js

@@ -3,10 +3,16 @@ import { platformSurfaces } from '../../core/context/platform-registry.js';
 import { defaultHttpApi } from '../../core/context/http.js';
 import { integrationSurfaceKeys, } from '../../core/context/types.js';
 import { bindEnvService } from '../../core/context/env.js';
-import { REQUEST_ID_HEADER } from './request-id.js';
-function rpcLogger(c) {
+import { REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, formatRuntimeVersion, } from './request-id.js';
+function rpcLogger(c, getTags, waitUntil) {
     const emit = (level, message, extra) => {
-        void c.log.emit.mutate({ level, message, extra }).catch(() => { });
+        const pending = c.log.emit.mutate({ level, message, extra, tags: getTags?.() }).catch(() => { });
+        if (waitUntil) {
+            waitUntil(pending);
+        }
+        else {
+            void pending;
+        }
     };
     return {
         info: (message, extra) => emit('info', message, extra),
@@ -80,6 +86,7 @@ export function createRpcApiHost(options) {
                         headers: async () => {
                             const headers = {
                                 authorization: `Bearer ${await options.getToken()}`,
+                                [RUNTIME_VERSION_HEADER]: formatRuntimeVersion(options.runtimeVersion, options.runtimeSource),
                             };
                             const requestId = options.getRequestId?.();
                             if (requestId)
@@ -100,7 +107,7 @@ export function createRpcApiHost(options) {
             return {
                 ...buildPlatformApis(c),
                 integration: buildSurfaces(c, metas),
-                log: rpcLogger(c),
+                log: rpcLogger(c, options.getTags, options.waitUntil),
                 http: defaultHttpApi(),
             };
         },

package/dist/fn-context/rpc/trpc-init.d.ts

@@ -2,6 +2,7 @@ import type { RunScope } from '../types.js';
 export type RpcContext = {
     run: RunScope;
     requestId?: string;
+    runtimeVersion?: string;
 };
 export declare const router: import("@trpc/server").TRPCRouterBuilder<{
     ctx: RpcContext;

package/dist/fn-context/rpc/trpc-router-factory.d.ts

@@ -72,6 +72,7 @@ export declare function createAppRouter(modules: {
                 level: "error" | "info" | "warn";
                 message: string;
                 extra?: Record<string, unknown> | undefined;
+                tags?: string[] | undefined;
             };
             output: {
                 ok: true;

package/dist/index.d.ts

@@ -19,18 +19,18 @@ export { twilioCreateCallInput, twilioCreateCallOutput, twilioIncomingNumber, tw
 export type { ApplyWritesOptions, ApplyWritesResult, CompiledSlotSchema, ExtractedField, FieldHistoryEntry, FieldValue, HistoryAppend, MultiRowProjection, MultiRowRecord, MultiRowTableData, RecomputeResult, RuntimeDerivedFieldDef, RuntimeFieldDef, RuntimeNormalFieldDef, RuntimeSlotsSnapshot, RuntimeTableDef, SingleRowProjection, SingleRowTableData, SlotCurrent, SlotFillingOutput, SlotFillingValidateResult, TableData, UpdatedBy, ValidationIssue, ValidationResult, WriteSource, } from './core/slot/types.js';
 export type { FuncRef } from './core/functions/func-ref.js';
 export { resolveFuncName } from './core/functions/func-ref.js';
-export type { SequenceBuild } from './builder/types.js';
+export type { RuntimePackageSource, SequenceBuild } from './builder/types.js';
 export type { CaseContextViewRegistryEntry, ComputeFn, CustomFn, DefinedFunc, FuncMap, FuncOptions, FuncRegistration, FunctionCall, FunctionCtx, FunctionRegistry, FunctionRegistryEntry, GetFirstMessageFunction, GetFirstMessageParams, SystemFuncMap, WebHookFunction, WebHookFunctionParams, } from './core/functions/types.js';
 export { toFuncRegistrations } from './core/functions/types.js';
 export { toCaseContextViewRegistry, toFunctionRegistry } from './builder/compile/registry.js';
 export { compileFunctionCode } from './builder/compile/function-code.js';
-export { compileAll, compileSequence, runtimePackageVersion, snapshotCompanySchema, type CompileSequenceOptions, type CompileSequenceResult, } from './builder/compile/compile-sequence.js';
+export { compileAll, compileSequence, runtimePackageSource, runtimePackageVersion, snapshotCompanySchema, type CompileSequenceOptions, type CompileSequenceResult, } from './builder/compile/compile-sequence.js';
 export { compileSequenceAgendas, fatalAgendaIssues } from './builder/compile/compile-agenda.js';
 export { loadSequenceCaseContextView, loadSequenceFunctions } from './builder/load.js';
 export { findTsModule } from './builder/paths.js';
 export type { OverlayClientMessage, OverlayExecuteMessage, OverlayExecuteResultMessage, OverlayAuthErrorMessage, OverlayAuthMessage, OverlayAuthOkMessage, OverlayMessage, OverlayPushMessage, OverlayReplacedMessage, OverlayServerMessage, } from './dev-overlay/protocol.js';
 export { encodeOverlayMessage, OVERLAY_REPLACED_CLOSE_CODE, parseOverlayMessage } from './dev-overlay/protocol.js';
-export { buildActionContext, bindLogMeta, createFakeApiHost, defaultPlatformApis, emptyIntegration, createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader, makeCtx, makeCtxAsync, noopLog, type ActionContext, type ActionDataSlice, type ApiHost, type FakeApiHostOptions, type RunScope, } from './fn-context/index.js';
+export { buildActionContext, bindLogMeta, createFakeApiHost, defaultPlatformApis, emptyIntegration, createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, makeCtx, makeCtxAsync, noopLog, type ActionContext, type ActionDataSlice, type ApiHost, type FakeApiHostOptions, type RunScope, } from './fn-context/index.js';
 export { createAppRouter, createIntegrationRouter, createListBindingsProcedure, createLogRouter, createPlatformRouter, isRpcCodedError, parseScriptInput, ScriptInputError, type AppRouter, type RpcCodedError, type RpcErrorCode, type IntegrationInvokeHandler, type LogEmitHandler, type PlatformInvokeHandler, type RpcContext, } from './fn-context/rpc/index.js';
 export * from './compute-host/index.js';
 export { defineBoolComputeFunc, defineComputeFunc } from './core/functions/define/compute.js';

package/dist/index.js

@@ -14,12 +14,12 @@ export { resolveFuncName } from './core/functions/func-ref.js';
 export { toFuncRegistrations } from './core/functions/types.js';
 export { toCaseContextViewRegistry, toFunctionRegistry } from './builder/compile/registry.js';
 export { compileFunctionCode } from './builder/compile/function-code.js';
-export { compileAll, compileSequence, runtimePackageVersion, snapshotCompanySchema, } from './builder/compile/compile-sequence.js';
+export { compileAll, compileSequence, runtimePackageSource, runtimePackageVersion, snapshotCompanySchema, } from './builder/compile/compile-sequence.js';
 export { compileSequenceAgendas, fatalAgendaIssues } from './builder/compile/compile-agenda.js';
 export { loadSequenceCaseContextView, loadSequenceFunctions } from './builder/load.js';
 export { findTsModule } from './builder/paths.js';
 export { encodeOverlayMessage, OVERLAY_REPLACED_CLOSE_CODE, parseOverlayMessage } from './dev-overlay/protocol.js';
-export { buildActionContext, bindLogMeta, createFakeApiHost, defaultPlatformApis, emptyIntegration, createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader, makeCtx, makeCtxAsync, noopLog, } from './fn-context/index.js';
+export { buildActionContext, bindLogMeta, createFakeApiHost, defaultPlatformApis, emptyIntegration, createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, makeCtx, makeCtxAsync, noopLog, } from './fn-context/index.js';
 export { createAppRouter, createIntegrationRouter, createListBindingsProcedure, createLogRouter, createPlatformRouter, isRpcCodedError, parseScriptInput, ScriptInputError, } from './fn-context/rpc/index.js';
 export * from './compute-host/index.js';
 export { defineBoolComputeFunc, defineComputeFunc } from './core/functions/define/compute.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superpanel-sdk/runtime",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Slot + Stage runtime: schema, writes, derived recompute, agenda compile/walk/simulate",
   "license": "UNLICENSED",
   "type": "module",