@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/builder/load.d.ts

@@ -0,0 +1,22 @@
+import { type CaseContextViewFn } from '../core/functions/define/case-context.js';
+import type { FuncMap } from '../core/functions/types.js';
+import type { CompanySchema, SequenceSlots } from '../core/slot/schema.js';
+/** Sequence ids that have a slots.ts / slots/index.ts module. */
+export declare function listSequenceIds(repoRoot: string): string[];
+export declare function loadCompanySchema(schemaPath: string): Promise<CompanySchema>;
+export declare function loadSequenceSlots(slotsPath: string): Promise<SequenceSlots>;
+/**
+ * Load sequence `functions` map from functions.ts or functions/index.ts.
+ * Accepts named `functions` or default export FuncMap.
+ */
+export declare function loadSequenceFunctions(functionsPath: string): Promise<FuncMap>;
+/**
+ * Load optional `caseContextView` from view.ts / view/index.ts.
+ */
+export declare function loadSequenceCaseContextView(viewPath: string): Promise<CaseContextViewFn>;
+/**
+ * Load optional sequence agendas from agendas.ts / agendas/index.ts.
+ * Missing module → null (compile produces an empty agendas map).
+ */
+export declare function loadSequenceAgendas(agendasPath: string): Promise<unknown>;
+//# sourceMappingURL=load.d.ts.map

package/dist/builder/load.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+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 { 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()}`);
+    return mod;
+}
+function isFuncMap(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    for (const entry of Object.values(value)) {
+        if (entry == null || typeof entry !== 'object' || Array.isArray(entry)) {
+            return false;
+        }
+        const kind = entry.kind;
+        if (kind !== 'compute' && kind !== 'boolCompute' && kind !== 'custom' && kind !== 'system') {
+            return false;
+        }
+    }
+    return true;
+}
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function looksLikeTable(value) {
+    return isPlainObject(value) && isPlainObject(value.fields);
+}
+function isCompanySchema(value) {
+    if (!isPlainObject(value))
+        return false;
+    const entries = Object.values(value);
+    return entries.length > 0 && entries.every(looksLikeTable);
+}
+function isSequenceSlots(value) {
+    return isPlainObject(value) && looksLikeTable(value.session);
+}
+/**
+ * Resolve the config object from a dynamically imported module.
+ *
+ * Accepted authoring styles (first match wins):
+ * 1. Named export — `export const slots = { session, … }`
+ * 2. Default export is the config
+ * 3. Default export is a bag that holds a named key
+ */
+function pickExport(mod, names, label, isConfig) {
+    for (const name of names) {
+        if (Object.hasOwn(mod, name) && isConfig(mod[name])) {
+            return mod[name];
+        }
+    }
+    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
+    if (isConfig(defaultExport)) {
+        return defaultExport;
+    }
+    if (isPlainObject(defaultExport)) {
+        for (const name of names) {
+            if (Object.hasOwn(defaultExport, name) && isConfig(defaultExport[name])) {
+                return defaultExport[name];
+            }
+        }
+    }
+    throw new Error(`Could not find ${label} export (${names.join(' | ')}) in module`);
+}
+/** Sequence ids that have a slots.ts / slots/index.ts module. */
+export function listSequenceIds(repoRoot) {
+    const sequencesDir = path.join(repoRoot, 'sequences');
+    if (!existsSync(sequencesDir)) {
+        return [];
+    }
+    return readdirSync(sequencesDir)
+        .filter((name) => {
+        try {
+            return (statSync(path.join(sequencesDir, name)).isDirectory() &&
+                findTsModule(path.join(sequencesDir, name), 'slots') !== undefined);
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+}
+export async function loadCompanySchema(schemaPath) {
+    const mod = await importModule(schemaPath);
+    return pickExport(mod, ['companySchema', 'schema'], 'company schema', isCompanySchema);
+}
+export async function loadSequenceSlots(slotsPath) {
+    const mod = await importModule(slotsPath);
+    return pickExport(mod, ['slots'], 'sequence slots', isSequenceSlots);
+}
+/**
+ * Load sequence `functions` map from functions.ts or functions/index.ts.
+ * Accepts named `functions` or default export FuncMap.
+ */
+export async function loadSequenceFunctions(functionsPath) {
+    const mod = await importModule(functionsPath);
+    if (Object.hasOwn(mod, 'functions') && isFuncMap(mod.functions)) {
+        return mod.functions;
+    }
+    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
+    if (isFuncMap(defaultExport)) {
+        return defaultExport;
+    }
+    if (defaultExport != null && typeof defaultExport === 'object' && !Array.isArray(defaultExport)) {
+        const bag = defaultExport;
+        if (Object.hasOwn(bag, 'functions') && isFuncMap(bag.functions)) {
+            return bag.functions;
+        }
+    }
+    throw new Error(`Could not find functions export (functions | default) as a FuncMap in ${functionsPath}`);
+}
+/**
+ * Load optional `caseContextView` from view.ts / view/index.ts.
+ */
+export async function loadSequenceCaseContextView(viewPath) {
+    const mod = await importModule(viewPath);
+    const fromNamed = resolveCaseContextViewFn(mod.caseContextView);
+    if (fromNamed)
+        return fromNamed;
+    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
+    const fromDefault = resolveCaseContextViewFn(defaultExport);
+    if (fromDefault)
+        return fromDefault;
+    if (defaultExport != null && typeof defaultExport === 'object' && !Array.isArray(defaultExport)) {
+        const fromBag = resolveCaseContextViewFn(defaultExport.caseContextView);
+        if (fromBag)
+            return fromBag;
+    }
+    throw new Error(`Could not find caseContextView export (caseContextView | default) as a function in ${viewPath}`);
+}
+function isAgendasExport(value) {
+    if (value == null)
+        return false;
+    if (isSequenceAgendas(value) || isAgendaTree(value))
+        return true;
+    if (Array.isArray(value) && value.length > 0 && value.every(isAgendaTree))
+        return true;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const values = Object.values(value);
+        return values.length > 0 && values.every(isAgendaTree);
+    }
+    return false;
+}
+/**
+ * Load optional sequence agendas from agendas.ts / agendas/index.ts.
+ * Missing module → null (compile produces an empty agendas map).
+ */
+export async function loadSequenceAgendas(agendasPath) {
+    const mod = await importModule(agendasPath);
+    if (Object.hasOwn(mod, 'agendas') && isAgendasExport(mod.agendas)) {
+        return mod.agendas;
+    }
+    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
+    if (isAgendasExport(defaultExport))
+        return defaultExport;
+    if (defaultExport != null && typeof defaultExport === 'object' && !Array.isArray(defaultExport)) {
+        const bag = defaultExport;
+        if (Object.hasOwn(bag, 'agendas') && isAgendasExport(bag.agendas)) {
+            return bag.agendas;
+        }
+    }
+    throw new Error(`Could not find agendas export (agendas | default) in ${agendasPath}`);
+}
+//# sourceMappingURL=load.js.map

package/dist/builder/merge.d.ts

@@ -0,0 +1,4 @@
+import type { CompanySchema, EffectiveSchema, SequenceSlots } from '../core/slot/schema.js';
+/** Merge company schema + sequence slots view into effective schema for codegen. */
+export declare function mergeEffectiveSchema(company: CompanySchema, sequenceSlots: SequenceSlots): EffectiveSchema;
+//# sourceMappingURL=merge.d.ts.map

package/dist/builder/merge.js

@@ -0,0 +1,19 @@
+import { compileSlotSchema, toEffectiveSchema } from '../core/slot/compile-schema.js';
+/** Merge company schema + sequence slots view into effective schema for codegen. */
+export function mergeEffectiveSchema(company, sequenceSlots) {
+    const { schema, validation } = compileSlotSchema(company, sequenceSlots);
+    if (!validation.ok) {
+        const fatal = validation.issues.filter((i) => i.code === 'unknown-table' ||
+            i.code === 'unknown-field' ||
+            i.code === 'unknown-ref-table' ||
+            i.code === 'invalid-id-field' ||
+            i.code === 'missing-id-field' ||
+            i.code === 'id-cannot-ref' ||
+            i.code === 'reserved-table-name');
+        if (fatal.length > 0) {
+            throw new Error(fatal.map((i) => i.message).join('; '));
+        }
+    }
+    return toEffectiveSchema(schema);
+}
+//# sourceMappingURL=merge.js.map

package/dist/builder/paths.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * File form is preferred when both exist.
+ */
+export declare function tsModuleCandidates(dir: string, name: string): string[];
+/** Return the first existing candidate, or `undefined` if none exist. */
+export declare function findTsModule(dir: string, name: string): string | undefined;
+/** Return the first existing candidate, or throw with `missingMessage`. */
+export declare function resolveTsModule(dir: string, name: string, missingMessage: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/builder/paths.js

@@ -0,0 +1,22 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * File form is preferred when both exist.
+ */
+export function tsModuleCandidates(dir, name) {
+    return [path.join(dir, `${name}.ts`), path.join(dir, name, 'index.ts')];
+}
+/** Return the first existing candidate, or `undefined` if none exist. */
+export function findTsModule(dir, name) {
+    return tsModuleCandidates(dir, name).find((candidate) => existsSync(candidate));
+}
+/** Return the first existing candidate, or throw with `missingMessage`. */
+export function resolveTsModule(dir, name, missingMessage) {
+    const found = findTsModule(dir, name);
+    if (!found) {
+        throw new Error(missingMessage);
+    }
+    return found;
+}
+//# sourceMappingURL=paths.js.map

package/dist/builder/types.d.ts

@@ -0,0 +1,31 @@
+import type { CaseContextViewRegistryEntry, FunctionRegistry } from '../core/functions/types.js';
+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';
+/**
+ * Compiled sequence artifact (Manual §9 subset; grows over time).
+ * Omitted for now: paramsDefaults, schedulers, caseManual.
+ *
+ * Published builds include per-fn `code`. Local serve overlay uses the same
+ * type but omits `code` — functions run on the laptop via WebSocket.
+ */
+export type SequenceBuild = {
+    sequenceId: string;
+    sha: string;
+    engineVersion: string;
+    compiledAt: string;
+    companySchemaSnapshot: CompanySchema;
+    /** SlotEngine runtime schema (tables + derivedOrder / reverseDeps). */
+    schema: CompiledSlotSchema;
+    effectiveSchema: EffectiveSchema;
+    /** Per-function registry. `code` omitted on local overlay. */
+    functions: FunctionRegistry;
+    /**
+     * Optional CaseContext projector. `null` when sequence has no view.ts
+     * (functions receive Slots / identity CaseContext).
+     */
+    caseContextView: CaseContextViewRegistryEntry | null;
+    /** Flattened agendas keyed by agenda id. Empty when the sequence has no agendas module. */
+    agendas: Record<string, CompiledAgenda>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/builder/types.js

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

package/dist/cli/compile/index.d.ts

@@ -0,0 +1,4 @@
+export declare function runCompile(repoRoot: string, options?: {
+    sequenceId?: string;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/compile/index.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+import { compileAll } from '../../builder/compile/compile-sequence.js';
+export async function runCompile(repoRoot, options = {}) {
+    const results = await compileAll(repoRoot, {
+        sequenceIds: options.sequenceId ? [options.sequenceId] : undefined,
+    });
+    for (const result of results) {
+        console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { Command } from 'commander';
+import { runCompile } from './compile/index.js';
+import { runServe } from './serve/index.js';
+import { runTypeGen } from './type-gen/index.js';
+function loadCwdEnv() {
+    const file = path.join(process.cwd(), '.env');
+    if (!existsSync(file))
+        return;
+    process.loadEnvFile(file);
+}
+const program = new Command();
+program
+    .name('superpanel-sdk-runtime')
+    .description('Company-repo tooling: type generation and sequence compile')
+    .showHelpAfterError()
+    .configureHelp({ sortSubcommands: true });
+program
+    .command('type:gen')
+    .description('Regenerate TypeScript types under sequences/<id>/__gen/')
+    .option('--watch', 'Regenerate when schema or sequence sources change')
+    .option('--check', 'Exit 1 if any generated file is stale')
+    .action(async (options) => {
+    await runTypeGen(process.cwd(), {
+        watchMode: Boolean(options.watch),
+        checkMode: Boolean(options.check),
+    });
+});
+program
+    .command('compile')
+    .description('Write sequences/<id>/build/sequence-build.json')
+    .option('--sequence <id>', 'Compile a single sequence (default: all with slots)')
+    .action(async (options) => {
+    await runCompile(process.cwd(), { sequenceId: options.sequence });
+});
+program
+    .command('serve')
+    .description('Watch local sequences and overlay them onto a backend over WebSocket')
+    .option('--url <url>', 'Backend host or overlay WebSocket URL (env SUPERPANEL_SDK_BACKEND_URL)')
+    .option('--api-key <key>', 'Company API key (env SUPERPANEL_SDK_API_KEY)')
+    .option('--company <id>', 'Company id (env SUPERPANEL_SDK_COMPANY_ID)')
+    .option('--sequence <id>', 'Serve a single sequence (default: all with slots)')
+    .action(async (options) => {
+    await runServe(process.cwd(), {
+        url: options.url,
+        apiKey: options.apiKey,
+        companyId: options.company,
+        sequenceIds: options.sequence ? [options.sequence] : undefined,
+    });
+});
+async function main() {
+    loadCwdEnv();
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=index.js.map

package/dist/cli/serve/index.d.ts

@@ -0,0 +1,9 @@
+export type ServeOptions = {
+    url?: string;
+    apiKey?: string;
+    companyId?: string;
+    sequenceIds?: string[];
+};
+export declare function overlayWebSocketUrl(raw: string): string;
+export declare function runServe(repoRoot: string, options?: ServeOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map