@superpanel-sdk/runtime 0.0.1-internal.1

package/README.md

@@ -0,0 +1,35 @@
+# @superpanel-sdk/runtime
+
+Slot + Stage runtime used by company repos and the platform: schema, writes, derived recompute, agenda compile/walk/simulate, and company-repo CLI.
+
+This package is currently published as an **internal prerelease**. Install a tagged build, not `latest`:
+
+```bash
+npm i @superpanel-sdk/runtime@next
+```
+
+Requires Node.js `>=20.12`.
+
+## CLI
+
+```bash
+npx superpanel-sdk-runtime type:gen
+npx superpanel-sdk-runtime type:gen --watch
+npx superpanel-sdk-runtime type:gen --check
+npx superpanel-sdk-runtime compile
+npx superpanel-sdk-runtime compile --sequence <id>
+npx superpanel-sdk-runtime serve
+```
+
+`serve` reads `.env` from the current working directory:
+
+- `SUPERPANEL_SDK_COMPANY_ID` / `--company`
+- `SUPERPANEL_SDK_API_KEY` / `--api-key`
+- `SUPERPANEL_SDK_BACKEND_URL` / `--url`
+
+## Imports
+
+```ts
+import { makeCtx, applyWrites, createAppRouter } from '@superpanel-sdk/runtime';
+import { createFakeApiHost } from '@superpanel-sdk/runtime/fn-context';
+```

package/bin/superpanel-sdk-runtime.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const runtimeRoot = path.join(here, '..');
+const cli = path.join(runtimeRoot, 'dist', 'cli', 'index.js');
+
+// Resolve tsx from @superpanel-sdk/runtime (not the company-repo cwd).
+// Package export "." → dist/loader.mjs
+const requireFromRuntime = createRequire(path.join(runtimeRoot, 'package.json'));
+const tsxLoader = pathToFileURL(requireFromRuntime.resolve('tsx')).href;
+
+const result = spawnSync(process.execPath, ['--import', tsxLoader, cli, ...process.argv.slice(2)], {
+  cwd: process.cwd(),
+  stdio: 'inherit',
+  env: process.env,
+});
+
+process.exit(result.status ?? 1);

package/dist/builder/codegen/emit.d.ts

@@ -0,0 +1,17 @@
+import type { EffectiveSchema } from '../../core/slot/schema.js';
+/** Emit `__gen/slots.type.ts` — Slots only (no CaseContext; avoids cycle with view.ts). */
+export declare function emitSlotsSource(schema: EffectiveSchema): string;
+/**
+ * Emit `__gen/case-context.type.ts`.
+ * Separate from slots.type.ts so dependencies stay one-way:
+ *   view.ts → slots.type.ts
+ *   case-context.type.ts → view.ts | slots.type.ts
+ *   functions → case-context.type.ts
+ */
+export declare function emitCaseContextSource(options: {
+    hasCaseContextView: boolean;
+}): string;
+/** Stub written when a sequence has no gen file yet. */
+export declare function emitSlotsStub(): string;
+export declare function emitCaseContextStub(): string;
+//# sourceMappingURL=emit.d.ts.map

package/dist/builder/codegen/emit.js

@@ -0,0 +1,143 @@
+import { slotFieldEntries } from '../../core/slot/row.js';
+function quoteLiteral(v) {
+    return typeof v === 'number' ? String(v) : JSON.stringify(v);
+}
+function dataTypeToTs(dataType) {
+    switch (dataType) {
+        case 'string':
+        case 'date':
+        case 'datetime':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+    }
+}
+function valueTypeExpr(field) {
+    let base;
+    if (field.enum && field.enum.length > 0) {
+        base = field.enum.map(quoteLiteral).join(' | ');
+    }
+    else {
+        base = dataTypeToTs(field.dataType);
+    }
+    // Runtime envelopes always allow null on value (empty / declined / no conclusion).
+    if (field.nullable) {
+        return `${base} | null`;
+    }
+    return `${base} | null`;
+}
+function emitRowFields(fields) {
+    const fieldLines = [];
+    for (const [fieldName, field] of slotFieldEntries(fields)) {
+        const valueTs = valueTypeExpr(field);
+        fieldLines.push(`      ${fieldName}: FieldValueBase & { value: ${valueTs} };`);
+    }
+    return fieldLines;
+}
+function emitTableType(tableName, rows, fields) {
+    const fieldLines = emitRowFields(fields);
+    const rowBody = `      id: string;\n${fieldLines.join('\n')}`;
+    if (rows === 'multi') {
+        return `    ${tableName}: {
+${rowBody}
+    }[];`;
+    }
+    return `    ${tableName}: {
+${rowBody}
+    };`;
+}
+/** Emit `__gen/slots.type.ts` — Slots only (no CaseContext; avoids cycle with view.ts). */
+export function emitSlotsSource(schema) {
+    const tableBlocks = [];
+    for (const [tableName, table] of Object.entries(schema)) {
+        tableBlocks.push(emitTableType(tableName, table.rows, table.fields));
+    }
+    return `// GENERATED — do not edit
+// Source: company schema + sequence slots → effective schema
+// Regenerate: superpanel-sdk-runtime type:gen
+
+export type FieldState = "empty" | "filled" | "asked_unknown" | "declined";
+
+export type FieldHistoryEntry = {
+  value: string | number | boolean | null;
+  state: FieldState;
+  at: number;
+  by:
+    | "slot-filling"
+    | "derived"
+    | "function"
+    | "human"
+    | "import"
+    | "platform";
+};
+
+export type FieldValueBase = {
+  reason: string | null;
+  state: FieldState;
+  updatedAt: number;
+  updatedBy:
+    | "slot-filling"
+    | "derived"
+    | "function"
+    | "human"
+    | "import"
+    | "platform";
+  history: FieldHistoryEntry[];
+};
+
+export type Slots = {
+  current: {
+    contactId: string;
+    caseContactId: string;
+    caseFileId: string;
+    sessionId: string | null;
+  };
+${tableBlocks.join('\n')}
+};
+`;
+}
+/**
+ * Emit `__gen/case-context.type.ts`.
+ * Separate from slots.type.ts so dependencies stay one-way:
+ *   view.ts → slots.type.ts
+ *   case-context.type.ts → view.ts | slots.type.ts
+ *   functions → case-context.type.ts
+ */
+export function emitCaseContextSource(options) {
+    if (options.hasCaseContextView) {
+        return `// GENERATED — do not edit
+// CaseContext from sequence view.ts
+// Regenerate: superpanel-sdk-runtime type:gen
+
+export type { CaseContext } from '../view.ts';
+`;
+    }
+    return `// GENERATED — do not edit
+// No view.ts — CaseContext is identity with Slots
+// Regenerate: superpanel-sdk-runtime type:gen
+
+import type { Slots } from './slots.type.ts';
+
+export type CaseContext = Slots;
+`;
+}
+/** Stub written when a sequence has no gen file yet. */
+export function emitSlotsStub() {
+    return `// GENERATED — do not edit
+// Stub — run: superpanel-sdk-runtime type:gen
+
+export type Slots = Record<string, unknown>;
+`;
+}
+export function emitCaseContextStub() {
+    return `// GENERATED — do not edit
+// Stub — run: superpanel-sdk-runtime type:gen
+
+import type { Slots } from './slots.type.ts';
+
+export type CaseContext = Slots;
+`;
+}
+//# sourceMappingURL=emit.js.map

package/dist/builder/codegen/generate.d.ts

@@ -0,0 +1,21 @@
+import { listSequenceIds } from '../load.js';
+export { listSequenceIds };
+export type GenerateResult = {
+    sequenceId: string;
+    outPath: string;
+    caseContextOutPath: string;
+    source: string;
+    caseContextSource: string;
+    wrote: boolean;
+};
+export declare function generateSequence(repoRoot: string, sequenceId: string, options?: {
+    dryRun?: boolean;
+}): Promise<GenerateResult>;
+export declare function generateAll(repoRoot: string, options?: {
+    dryRun?: boolean;
+    sequenceIds?: string[];
+}): Promise<GenerateResult[]>;
+export declare function checkSequence(repoRoot: string, sequenceId: string): Promise<void>;
+export declare function checkAll(repoRoot: string): Promise<void>;
+export declare function ensureStub(repoRoot: string, sequenceId: string): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/builder/codegen/generate.js

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { listSequenceIds, loadCompanySchema, loadSequenceSlots } from '../load.js';
+import { mergeEffectiveSchema } from '../merge.js';
+import { findTsModule, resolveTsModule } from '../paths.js';
+import { emitCaseContextSource, emitCaseContextStub, emitSlotsSource, emitSlotsStub } from './emit.js';
+export { listSequenceIds };
+function sequenceSlotsGenPath(repoRoot, sequenceId) {
+    return path.join(repoRoot, 'sequences', sequenceId, '__gen', 'slots.type.ts');
+}
+function sequenceCaseContextGenPath(repoRoot, sequenceId) {
+    return path.join(repoRoot, 'sequences', sequenceId, '__gen', 'case-context.type.ts');
+}
+export async function generateSequence(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);
+    const slots = await loadSequenceSlots(slotsPath);
+    const effective = mergeEffectiveSchema(company, slots);
+    const sequenceDir = path.join(repoRoot, 'sequences', sequenceId);
+    const hasCaseContextView = findTsModule(sequenceDir, 'view') !== undefined;
+    const source = emitSlotsSource(effective);
+    const caseContextSource = emitCaseContextSource({ hasCaseContextView });
+    const outPath = sequenceSlotsGenPath(repoRoot, sequenceId);
+    const caseContextOutPath = sequenceCaseContextGenPath(repoRoot, sequenceId);
+    if (!options.dryRun) {
+        mkdirSync(path.dirname(outPath), { recursive: true });
+        writeFileSync(outPath, source, 'utf8');
+        writeFileSync(caseContextOutPath, caseContextSource, 'utf8');
+    }
+    return {
+        sequenceId,
+        outPath,
+        caseContextOutPath,
+        source,
+        caseContextSource,
+        wrote: !options.dryRun,
+    };
+}
+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;
+}
+function assertFileMatches(outPath, next, repoRoot) {
+    let current = '';
+    try {
+        current = readFileSync(outPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Missing ${outPath}; run: superpanel-sdk-runtime type:gen`);
+    }
+    if (current !== next) {
+        throw new Error(`${path.relative(repoRoot, outPath)} is stale. Run \`superpanel-sdk-runtime type:gen\`.`);
+    }
+}
+export async function checkSequence(repoRoot, sequenceId) {
+    const { outPath, caseContextOutPath, source, caseContextSource } = await generateSequence(repoRoot, sequenceId, {
+        dryRun: true,
+    });
+    assertFileMatches(outPath, source, repoRoot);
+    assertFileMatches(caseContextOutPath, caseContextSource, repoRoot);
+}
+export async function checkAll(repoRoot) {
+    const ids = 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)`);
+    }
+    for (const sequenceId of ids) {
+        await checkSequence(repoRoot, sequenceId);
+    }
+}
+export function ensureStub(repoRoot, sequenceId) {
+    const slotsPath = sequenceSlotsGenPath(repoRoot, sequenceId);
+    const caseContextPath = sequenceCaseContextGenPath(repoRoot, sequenceId);
+    mkdirSync(path.dirname(slotsPath), { recursive: true });
+    if (!existsSync(slotsPath)) {
+        writeFileSync(slotsPath, emitSlotsStub(), 'utf8');
+    }
+    if (!existsSync(caseContextPath)) {
+        writeFileSync(caseContextPath, emitCaseContextStub(), 'utf8');
+    }
+}
+//# sourceMappingURL=generate.js.map

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

@@ -0,0 +1,15 @@
+import type { EffectiveSchema } from '../../core/slot/schema.js';
+import type { CompiledSlotSchema, ValidationIssue } from '../../core/slot/types.js';
+import type { FuncMap } from '../../core/functions/types.js';
+import { fatalAgendaIssues, type CompiledAgenda } from '../../core/stage/index.js';
+export type CompileAgendasResult = {
+    schema: CompiledSlotSchema;
+    effectiveSchema: EffectiveSchema;
+    agendas: Record<string, CompiledAgenda>;
+    issues: ValidationIssue[];
+};
+export declare function compileSequenceAgendas(schema: CompiledSlotSchema, raw: unknown, options?: {
+    functions?: FuncMap;
+}): CompileAgendasResult;
+export { fatalAgendaIssues };
+//# sourceMappingURL=compile-agenda.d.ts.map

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

@@ -0,0 +1,59 @@
+import { toEffectiveSchema } from '../../core/slot/compile-schema.js';
+import { collectTransferBlocks, fatalAgendaIssues, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, registerTransferSessionFields, validateCompiledAgenda, } from '../../core/stage/index.js';
+function asAgendaTrees(raw) {
+    if (isAgendaTree(raw))
+        return [raw];
+    if (Array.isArray(raw) && raw.length > 0 && raw.every(isAgendaTree))
+        return raw;
+    if (raw != null && typeof raw === 'object' && !Array.isArray(raw) && !isSequenceAgendas(raw)) {
+        const values = Object.values(raw);
+        if (values.length > 0 && values.every(isAgendaTree))
+            return values;
+    }
+    return null;
+}
+function compileOneFlat(agendaId, header, flattened, schema, functions, issues) {
+    issues.push(...flattened.issues);
+    const agenda = { header, flat: flattened.items };
+    const validated = validateCompiledAgenda(agenda, { schema, functions, agendaId });
+    if (!validated.ok)
+        issues.push(...validated.issues);
+    return agenda;
+}
+export function compileSequenceAgendas(schema, raw, options = {}) {
+    const issues = [];
+    if (raw == null) {
+        return { schema, effectiveSchema: toEffectiveSchema(schema), agendas: {}, issues };
+    }
+    const trees = asAgendaTrees(raw);
+    if (trees) {
+        const transferIds = collectTransferBlocks({}, trees.flatMap((tree) => tree.tree)).map((block) => block.id);
+        const withTransfer = registerTransferSessionFields(schema, transferIds);
+        const compiled = {};
+        for (const tree of trees) {
+            compiled[tree.id] = compileOneFlat(tree.id, tree.header, flattenAgendaTree(tree.tree, { functions: options.functions }), withTransfer, options.functions, issues);
+        }
+        return { schema: withTransfer, effectiveSchema: toEffectiveSchema(withTransfer), agendas: compiled, issues };
+    }
+    let agendasInput;
+    try {
+        agendasInput = isSequenceAgendas(raw) ? raw : normalizeSequenceAgendas(raw);
+    }
+    catch (error) {
+        issues.push({
+            code: 'invalid-agendas',
+            message: error instanceof Error ? error.message : String(error),
+            path: 'agendas',
+        });
+        return { schema, effectiveSchema: toEffectiveSchema(schema), agendas: {}, issues };
+    }
+    const transferIds = collectTransferBlocks(agendasInput.blocks).map((block) => block.id);
+    const withTransfer = registerTransferSessionFields(schema, transferIds);
+    const compiled = {};
+    for (const [agendaId, config] of Object.entries(agendasInput.agendas)) {
+        compiled[agendaId] = compileOneFlat(agendaId, config.header, flattenAgendaPlacements(config.placements, agendasInput.blocks, { functions: options.functions }), withTransfer, options.functions, issues);
+    }
+    return { schema: withTransfer, effectiveSchema: toEffectiveSchema(withTransfer), agendas: compiled, issues };
+}
+export { fatalAgendaIssues };
+//# sourceMappingURL=compile-agenda.js.map

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

@@ -0,0 +1,24 @@
+import type { FuncMap } from '../../core/functions/types.js';
+import type { CompanySchema } from '../../core/slot/schema.js';
+import type { SequenceBuild } from '../types.js';
+/** 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;
+export type CompileSequenceOptions = {
+    dryRun?: boolean;
+    /** When false, skip esbuild and omit registry `code` (local serve overlay). Default true. */
+    includeCode?: boolean;
+    /** Persist on SequenceBuild.sha. Defaults to `local`. */
+    sha?: string;
+};
+export type CompileSequenceResult = {
+    sequenceId: string;
+    outPath: string;
+    build: SequenceBuild;
+    wrote: boolean;
+};
+export declare function compileSequence(repoRoot: string, sequenceId: string, options?: CompileSequenceOptions): Promise<CompileSequenceResult>;
+export declare function compileAll(repoRoot: string, options?: CompileSequenceOptions & {
+    sequenceIds?: string[];
+}): Promise<CompileSequenceResult[]>;
+//# sourceMappingURL=compile-sequence.d.ts.map

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

@@ -0,0 +1,121 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+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 { listSequenceIds, loadCompanySchema, loadSequenceAgendas, loadSequenceCaseContextView, loadSequenceFunctions, loadSequenceSlots, } from '../load.js';
+import { findTsModule, resolveTsModule } from '../paths.js';
+import { compileSequenceAgendas, fatalAgendaIssues } from './compile-agenda.js';
+import { toCaseContextViewRegistry, toFunctionRegistry } from './registry.js';
+const FATAL_CODES = new Set([
+    'unknown-table',
+    'unknown-field',
+    'missing-session',
+    'missing-compute-fn',
+    'cyclic-dependency',
+    'multi-derived-forbidden',
+    'session-derived-forbidden',
+    'unknown-ref-table',
+    'invalid-id-field',
+    'missing-id-field',
+    'id-cannot-ref',
+    'reserved-table-name',
+]);
+function runtimePackageVersion() {
+    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version ?? '0.0.0';
+}
+/** Deep-clone company schema with derived computeFn normalized to string names. */
+export function snapshotCompanySchema(company, functions) {
+    const tables = {};
+    for (const [tableName, table] of Object.entries(company)) {
+        const fields = {};
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            if (field.derived) {
+                fields[fieldName] = {
+                    ...field,
+                    computeFn: resolveFuncName(field.computeFn, functions),
+                };
+            }
+            else {
+                fields[fieldName] = { ...field };
+            }
+        }
+        tables[tableName] = { ...table, fields };
+    }
+    return tables;
+}
+export function sequenceBuildPath(repoRoot, sequenceId) {
+    return path.join(repoRoot, 'sequences', sequenceId, 'build', 'sequence-build.json');
+}
+export async function compileSequence(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`);
+    const functionsPath = findTsModule(sequenceDir, 'functions');
+    if (!functionsPath) {
+        throw new Error(`No sequence functions found. Expected sequences/${sequenceId}/functions.ts or sequences/${sequenceId}/functions/index.ts`);
+    }
+    const company = await loadCompanySchema(schemaPath);
+    const slots = await loadSequenceSlots(slotsPath);
+    const functions = await loadSequenceFunctions(functionsPath);
+    const viewPath = findTsModule(sequenceDir, 'view');
+    const caseContextView = viewPath ? await loadSequenceCaseContextView(viewPath) : undefined;
+    if (viewPath && !resolveCaseContextViewFn(caseContextView)) {
+        throw new Error(`sequences/${sequenceId}/view.ts did not export a caseContextView function`);
+    }
+    const { schema, validation } = compileSlotSchema(company, slots, {
+        functions,
+        computeFns: new Set(Object.keys(functions)),
+    });
+    if (!validation.ok) {
+        const fatal = validation.issues.filter((i) => FATAL_CODES.has(i.code));
+        if (fatal.length > 0) {
+            throw new Error(fatal.map((i) => i.message).join('; '));
+        }
+    }
+    const agendasPath = findTsModule(sequenceDir, 'agendas');
+    const rawAgendas = agendasPath ? await loadSequenceAgendas(agendasPath) : null;
+    const compiledAgendas = compileSequenceAgendas(schema, rawAgendas, { functions });
+    const fatalAgenda = fatalAgendaIssues(compiledAgendas.issues);
+    if (fatalAgenda.length > 0) {
+        throw new Error(fatalAgenda.map((i) => i.message).join('; '));
+    }
+    const includeCode = options.includeCode ?? true;
+    const [functionsRegistry, caseContextViewEntry] = await Promise.all([
+        toFunctionRegistry(functions, { includeCode }),
+        toCaseContextViewRegistry(caseContextView, { includeCode }),
+    ]);
+    const build = {
+        sequenceId,
+        sha: options.sha ?? 'local',
+        engineVersion: runtimePackageVersion(),
+        compiledAt: new Date().toISOString(),
+        companySchemaSnapshot: snapshotCompanySchema(company, functions),
+        schema: compiledAgendas.schema,
+        effectiveSchema: compiledAgendas.effectiveSchema,
+        functions: functionsRegistry,
+        caseContextView: caseContextViewEntry,
+        agendas: compiledAgendas.agendas,
+    };
+    const outPath = sequenceBuildPath(repoRoot, sequenceId);
+    if (!options.dryRun) {
+        mkdirSync(path.dirname(outPath), { recursive: true });
+        writeFileSync(outPath, `${JSON.stringify(build, null, 2)}\n`, 'utf8');
+    }
+    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;
+}
+//# sourceMappingURL=compile-sequence.js.map

package/dist/builder/compile/function-code.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compile a single function implementation to a standalone JS expression string
+ * suitable for QuickJS `eval` / registry `code` fields (minified).
+ */
+export declare function compileFunctionCode(fn: (...args: never[]) => unknown): Promise<string>;
+//# sourceMappingURL=function-code.d.ts.map

package/dist/builder/compile/function-code.js

@@ -0,0 +1,30 @@
+import * as esbuild from 'esbuild';
+/**
+ * Compile a single function implementation to a standalone JS expression string
+ * suitable for QuickJS `eval` / registry `code` fields (minified).
+ */
+export async function compileFunctionCode(fn) {
+    const raw = fn.toString().trim();
+    // No `format:` — esbuild emits `export default <expr>;` (stable to strip).
+    const result = await esbuild.transform(`export default ${raw}`, {
+        loader: 'js',
+        target: 'es2022',
+        minify: true,
+        logLevel: 'silent',
+    });
+    const text = result.code.trim();
+    if (text.includes('@superpanel-sdk/runtime') ||
+        text.includes('defineComputeFunc') ||
+        text.includes('defineCustomFunc') ||
+        text.includes('defineBoolComputeFunc') ||
+        text.includes('defineSystemFunc') ||
+        text.includes('defineCaseContext')) {
+        throw new Error('compiled function code still references define* / @superpanel-sdk/runtime');
+    }
+    const m = /^export\s+default\s*/.exec(text);
+    if (!m) {
+        throw new Error(`Unexpected esbuild emit (expected export default …):\n${text}`);
+    }
+    return text.slice(m[0].length).replace(/;?\s*$/, '');
+}
+//# sourceMappingURL=function-code.js.map

package/dist/builder/compile/registry.d.ts

@@ -0,0 +1,13 @@
+import type { CaseContextViewRegistryEntry, FuncMap, FunctionRegistry } from '../../core/functions/types.js';
+export type BuildRegistryOptions = {
+    /** When false, skip esbuild and omit `code` (local serve overlay). Default true. */
+    includeCode?: boolean;
+};
+/**
+ * Project author FuncMap → JSON-safe registry.
+ * Published builds include per-function compiled `code`; overlay omits it.
+ */
+export declare function toFunctionRegistry(functions: FuncMap, options?: BuildRegistryOptions): Promise<FunctionRegistry>;
+/** Compile optional caseContextView to registry entry. */
+export declare function toCaseContextViewRegistry(view: unknown, options?: BuildRegistryOptions): Promise<CaseContextViewRegistryEntry | null>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/builder/compile/registry.js

@@ -0,0 +1,42 @@
+import { resolveCaseContextViewFn } from '../../core/functions/define/case-context.js';
+import { compileFunctionCode } from './function-code.js';
+function withCode(entry, code) {
+    if (code === undefined)
+        return entry;
+    return { ...entry, code };
+}
+/**
+ * Project author FuncMap → JSON-safe registry.
+ * Published builds include per-function compiled `code`; overlay omits it.
+ */
+export async function toFunctionRegistry(functions, options = {}) {
+    const includeCode = options.includeCode ?? true;
+    const out = {};
+    for (const [name, def] of Object.entries(functions)) {
+        const code = includeCode ? await compileFunctionCode(def.main) : undefined;
+        let entry;
+        if (def.kind === 'custom') {
+            entry = withCode({ kind: 'custom', writes: [] }, code);
+        }
+        else if (def.kind === 'system') {
+            entry = withCode({ kind: 'system' }, code);
+        }
+        else {
+            entry = withCode({ kind: def.kind }, code);
+        }
+        out[name] = entry;
+    }
+    return out;
+}
+/** Compile optional caseContextView to registry entry. */
+export async function toCaseContextViewRegistry(view, options = {}) {
+    const fn = resolveCaseContextViewFn(view);
+    if (!fn)
+        return null;
+    if (!(options.includeCode ?? true)) {
+        return { kind: 'caseContextView' };
+    }
+    const code = await compileFunctionCode(fn);
+    return { kind: 'caseContextView', code };
+}
+//# sourceMappingURL=registry.js.map