@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/core/context/types.d.ts

@@ -0,0 +1,87 @@
+import type { FieldPath } from '../slot/path.js';
+import type { PlatformApis } from './platform-registry.js';
+import type { DocusignApi } from './docusign.js';
+import type { EnvApi } from './env.js';
+import type { FilevineApi } from './filevine.js';
+import type { HubspotApi } from './hubspot.js';
+import type { TwilioApi } from './twilio.js';
+import type { HttpApi } from './http.js';
+import type { IntegrationAccountFields } from './account-fields.js';
+export type { IntegrationAccountFields, IntegrationTarget } from './account-fields.js';
+export type FieldState = 'empty' | 'filled' | 'asked_unknown' | 'declined';
+/**
+ * Fallback Slots. Sequence `__gen/slots.type.ts` provides the narrowed shape;
+ * `view.ts` selectors import that type.
+ */
+export type Slots = Record<string, unknown>;
+/**
+ * Fallback CaseContext (no view / before narrowing).
+ * With `view.ts`, use `CaseContextOf<typeof caseContextView>` from that module.
+ */
+export type CaseContext = Record<string, unknown>;
+export type Writes = Record<FieldPath, unknown>;
+export type Logger = {
+    info: (message: string, extra?: Record<string, unknown>) => void;
+    warn: (message: string, extra?: Record<string, unknown>) => void;
+    error: (message: string, extra?: Record<string, unknown>) => void;
+};
+export type { DocusignApi, DocusignService } from './docusign.js';
+export type { EnvApi, EnvService } from './env.js';
+export type { FilevineApi, FilevineService } from './filevine.js';
+export type { HubspotApi, HubspotService } from './hubspot.js';
+export type { TwilioApi, TwilioCreateCallInput, TwilioCreateCallOutput, TwilioIncomingNumber, TwilioListIncomingNumbersOutput, TwilioSendSmsInput, TwilioSendSmsOutput, TwilioService, } from './twilio.js';
+export type { ContactApi, ContactListParams, ContactListResult, ContactSummary } from './contact.js';
+export type { HttpApi } from './http.js';
+/**
+ * Integration API: surfaceKey → array of bound stubs.
+ * Add a key here when the platform adds a script surface; the provider table must implement it.
+ */
+export type IntegrationApi = {
+    hubspots?: HubspotApi[];
+    twilios?: TwilioApi[];
+    filevines?: FilevineApi[];
+    docusigns?: DocusignApi[];
+    envs?: EnvApi[];
+};
+export type IntegrationSurfaceKey = keyof IntegrationApi;
+type SurfaceItem<K extends IntegrationSurfaceKey> = NonNullable<IntegrationApi[K]>[number];
+export type IntegrationStub = SurfaceItem<IntegrationSurfaceKey>;
+export declare const integrationSurfaceKeys: readonly ["hubspots", "twilios", "filevines", "docusigns", "envs"];
+export type BoundIntegrationMeta = IntegrationAccountFields & {
+    surfaceKey: IntegrationSurfaceKey;
+    methods: string[];
+};
+/** Context injected into custom and system functions. */
+export type SystemContext = {
+    time: Readonly<{
+        now: number;
+        timezone: string;
+        today: string;
+    }>;
+    meta: Readonly<{
+        companyId: string;
+        environmentId: string;
+        sequenceId: string;
+        entry: string;
+        contactId: string;
+        caseId: string;
+    }>;
+    config: Readonly<{
+        frontendUrl: string;
+        backendUrl: string;
+    }>;
+    api: PlatformApis & {
+        integration: IntegrationApi;
+        log: Logger;
+        http: HttpApi;
+    };
+};
+export type MakeCtxOverrides = {
+    today?: string;
+    timezone?: string;
+    now?: number;
+    meta?: Partial<SystemContext['meta']>;
+    config?: Partial<SystemContext['config']>;
+    api?: Partial<SystemContext['api']>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/context/types.js

@@ -0,0 +1,9 @@
+export const integrationSurfaceKeys = [
+    'hubspots',
+    'twilios',
+    'filevines',
+    'docusigns',
+    'envs',
+];
+true;
+//# sourceMappingURL=types.js.map

package/dist/core/functions/define/case-context.d.ts

@@ -0,0 +1,14 @@
+/** `(slots) => CaseContext` — pure projection; not persisted. */
+export type CaseContextViewFn<S = unknown, C = unknown> = (slots: S) => C;
+/** Tagged by {@link defineCaseContext} so compile can find it. */
+export type DefinedCaseContextView<S = unknown, C = unknown> = CaseContextViewFn<S, C> & {
+    kind: 'caseContextView';
+    main: CaseContextViewFn<S, C>;
+};
+/** Mark a projector for sequence `view.ts`. */
+export declare function defineCaseContext<S, C>(main: CaseContextViewFn<S, C>): DefinedCaseContextView<S, C>;
+/** `export type CaseContext = CaseContextOf<typeof caseContextView>` */
+export type CaseContextOf<T> = T extends (...args: never) => infer C ? C : never;
+/** Unwrap for compile / host (prefers `.main` when tagged). */
+export declare function resolveCaseContextViewFn(value: unknown): CaseContextViewFn | undefined;
+//# sourceMappingURL=case-context.d.ts.map

package/dist/core/functions/define/case-context.js

@@ -0,0 +1,15 @@
+/** Mark a projector for sequence `view.ts`. */
+export function defineCaseContext(main) {
+    return Object.assign(main, { kind: 'caseContextView', main });
+}
+/** Unwrap for compile / host (prefers `.main` when tagged). */
+export function resolveCaseContextViewFn(value) {
+    if (typeof value !== 'function')
+        return undefined;
+    const tagged = value;
+    if (tagged.kind === 'caseContextView' && typeof tagged.main === 'function') {
+        return tagged.main;
+    }
+    return value;
+}
+//# sourceMappingURL=case-context.js.map

package/dist/core/functions/define/compute.d.ts

@@ -0,0 +1,7 @@
+import type { ComputeFn, DefinedFunc, FuncOptions } from '../types.js';
+import type { CaseContext } from '../../context/types.js';
+/** Pure compute / derived field fn. No I/O; no SystemContext. Name = functions-map key. */
+export declare function defineComputeFunc<S = CaseContext, R = unknown>(main: ComputeFn<S, R>, options?: FuncOptions): DefinedFunc;
+/** Boolean compute (finishWhen / applyWhen helpers). */
+export declare function defineBoolComputeFunc<S = CaseContext>(main: ComputeFn<S, boolean>, options?: FuncOptions): DefinedFunc;
+//# sourceMappingURL=compute.d.ts.map

package/dist/core/functions/define/compute.js

@@ -0,0 +1,17 @@
+/** Pure compute / derived field fn. No I/O; no SystemContext. Name = functions-map key. */
+export function defineComputeFunc(main, options) {
+    return {
+        kind: 'compute',
+        main: main,
+        ...options,
+    };
+}
+/** Boolean compute (finishWhen / applyWhen helpers). */
+export function defineBoolComputeFunc(main, options) {
+    return {
+        kind: 'boolCompute',
+        main: main,
+        ...options,
+    };
+}
+//# sourceMappingURL=compute.js.map

package/dist/core/functions/define/custom.d.ts

@@ -0,0 +1,4 @@
+import type { CustomFn, DefinedFunc, FuncOptions } from '../types.js';
+import type { CaseContext } from '../../context/types.js';
+export declare function defineCustomFunc<S = CaseContext>(main: CustomFn<S>, options?: FuncOptions): DefinedFunc;
+//# sourceMappingURL=custom.d.ts.map

package/dist/core/functions/define/custom.js

@@ -0,0 +1,8 @@
+export function defineCustomFunc(main, options) {
+    return {
+        kind: 'custom',
+        main: main,
+        ...options,
+    };
+}
+//# sourceMappingURL=custom.js.map

package/dist/core/functions/define/system.d.ts

@@ -0,0 +1,7 @@
+import type { DefinedFunc, FuncOptions, FunctionCall, WebHookFunctionParams } from '../types.js';
+/**
+ * Platform lifecycle / webhook entry. Register under the matching key
+ * (e.g. `webhook: defineSystemFunc(...)`, `getFirstMessage: defineSystemFunc(...)`).
+ */
+export declare function defineSystemFunc<P extends object = WebHookFunctionParams, R = void>(main: FunctionCall<P, R>, options?: FuncOptions): DefinedFunc;
+//# sourceMappingURL=system.d.ts.map

package/dist/core/functions/define/system.js

@@ -0,0 +1,12 @@
+/**
+ * Platform lifecycle / webhook entry. Register under the matching key
+ * (e.g. `webhook: defineSystemFunc(...)`, `getFirstMessage: defineSystemFunc(...)`).
+ */
+export function defineSystemFunc(main, options) {
+    return {
+        kind: 'system',
+        main: main,
+        ...options,
+    };
+}
+//# sourceMappingURL=system.js.map

package/dist/core/functions/func-ref.d.ts

@@ -0,0 +1,16 @@
+import type { DefinedFunc, FuncMap } from './types.js';
+/**
+ * Author-time function reference:
+ * - string key: `'computeIsQualified'`
+ * - map value: `functions.computeIsQualified` ({@link DefinedFunc})
+ *
+ * Compiled / runtime schemas always store the string name.
+ */
+export type FuncRef = string | DefinedFunc;
+/**
+ * Normalize a {@link FuncRef} to the functions-map key.
+ * Object refs need the same `functions` map for identity lookup
+ * (plain map values do not carry `name`).
+ */
+export declare function resolveFuncName(ref: FuncRef, functions?: FuncMap): string;
+//# sourceMappingURL=func-ref.d.ts.map

package/dist/core/functions/func-ref.js

@@ -0,0 +1,20 @@
+/**
+ * Normalize a {@link FuncRef} to the functions-map key.
+ * Object refs need the same `functions` map for identity lookup
+ * (plain map values do not carry `name`).
+ */
+export function resolveFuncName(ref, functions) {
+    if (typeof ref === 'string') {
+        if (!ref)
+            throw new Error('Function reference name must be a non-empty string');
+        return ref;
+    }
+    if (functions) {
+        for (const [key, value] of Object.entries(functions)) {
+            if (value === ref)
+                return key;
+        }
+    }
+    throw new Error('Invalid function reference; expected a string name or a value from the functions map');
+}
+//# sourceMappingURL=func-ref.js.map

package/dist/core/functions/types.d.ts

@@ -0,0 +1,78 @@
+import type { FieldPath } from '../slot/path.js';
+import type { CaseContext, SystemContext, Writes } from '../context/types.js';
+export type FuncOptions = {
+    args?: Record<string, unknown>;
+    description?: string;
+};
+/** First arg is CaseContext (or Slots when the sequence has no view). */
+export type ComputeFn<S = CaseContext, R = unknown> = (caseContext: S) => R | Promise<R>;
+export type CustomFn<S = CaseContext> = (caseContext: S, ctx: SystemContext) => Promise<Writes | null>;
+/** Inbound webhook request payload. */
+export type WebHookFunctionParams = {
+    headers: Record<string, string | string[] | undefined>;
+    body: unknown;
+    rawBody?: string;
+};
+export type FunctionCtx<Params extends object> = SystemContext & {
+    params: Params;
+};
+export type FunctionCall<Params extends object, Return> = (ctx: FunctionCtx<Params>) => Promise<Return>;
+export type WebHookFunction = FunctionCall<WebHookFunctionParams, void>;
+export type GetFirstMessageParams<S = CaseContext> = {
+    caseContext: S;
+};
+export type GetFirstMessageFunction<S = CaseContext> = FunctionCall<GetFirstMessageParams<S>, string>;
+/** Object-key → implementation type for platform-invoked entries. */
+export type SystemFuncMap = {
+    webhook: WebHookFunction;
+    getFirstMessage: GetFirstMessageFunction;
+};
+type FuncMeta = {
+    description?: string;
+    args?: Record<string, unknown>;
+};
+/** One entry in a plain `functions` map (`{ name: define*Func(...) }`). */
+export type DefinedFunc = (FuncMeta & {
+    kind: 'compute' | 'boolCompute';
+    /** Implementation retained for compile → registry `code`; stripped from JSON via toFunctionRegistry. */
+    main: ComputeFn;
+}) | (FuncMeta & {
+    kind: 'custom';
+    main: CustomFn;
+}) | (FuncMeta & {
+    kind: 'system';
+    main: FunctionCall<object, unknown>;
+});
+/** Author map: key is the function name. */
+export type FuncMap = Record<string, DefinedFunc>;
+/** Map entry with name stamped from the key (for platform loaders). */
+export type FuncRegistration = DefinedFunc & {
+    name: string;
+};
+type RegistryCode = {
+    /**
+     * Standalone JS function expression (esbuild-normalized).
+     * Present on published builds; omitted on local serve overlay (`includeCode: false`).
+     */
+    code?: string;
+};
+/** Compiled function registry entry shapes (JSON-safe). */
+export type FunctionRegistryEntry = (RegistryCode & {
+    kind: 'compute' | 'boolCompute';
+}) | (RegistryCode & {
+    kind: 'custom';
+    writes: FieldPath[];
+}) | (RegistryCode & {
+    kind: 'system';
+});
+export type FunctionRegistry = Record<string, FunctionRegistryEntry>;
+/** Compiled CaseContext projector (optional on SequenceBuild). */
+export type CaseContextViewRegistryEntry = {
+    kind: 'caseContextView';
+    /** Present on published builds; omitted on local serve overlay. */
+    code?: string;
+};
+/** Stamp `name` from object keys when the platform loads a functions map. */
+export declare function toFuncRegistrations(functions: FuncMap): FuncRegistration[];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/functions/types.js

@@ -0,0 +1,5 @@
+/** Stamp `name` from object keys when the platform loads a functions map. */
+export function toFuncRegistrations(functions) {
+    return Object.entries(functions).map(([name, def]) => ({ ...def, name }));
+}
+//# sourceMappingURL=types.js.map

package/dist/core/slot/compile-schema.d.ts

@@ -0,0 +1,24 @@
+import type { CompanySchema, EffectiveSchema, SequenceSlots } from './schema.js';
+import type { FuncMap } from '../functions/types.js';
+import type { CompiledSlotSchema, RuntimeTableDef, ValidationResult } from './types.js';
+import { type FieldPath } from './path.js';
+/**
+ * Inherit every company table, then apply sequence overlays + session.
+ */
+export declare function compileSlotSchema(company: CompanySchema, sequenceSlots: SequenceSlots, options?: {
+    computeFns?: ReadonlySet<string>;
+    functions?: FuncMap;
+}): {
+    schema: CompiledSlotSchema;
+    validation: ValidationResult;
+};
+/** Validate field paths exist on a compiled schema. */
+export declare function validateFieldRefs(schema: CompiledSlotSchema, refs: Iterable<string>): ValidationResult;
+export declare function getCompiledTable(schema: CompiledSlotSchema, tableName: string): RuntimeTableDef | undefined;
+export declare function compiledTableEntries(schema: CompiledSlotSchema): Array<[string, RuntimeTableDef]>;
+/** Snapshot / SF presentation: single → field dict, multi → row array. */
+export declare function isSnapshotSingleRow(table: RuntimeTableDef): boolean;
+/** Effective schema for Slots codegen (multi → array, single → dict). */
+export declare function toEffectiveSchema(compiled: CompiledSlotSchema): EffectiveSchema;
+export declare function listConversationFields(schema: CompiledSlotSchema): FieldPath[];
+//# sourceMappingURL=compile-schema.d.ts.map

package/dist/core/slot/compile-schema.js

@@ -0,0 +1,336 @@
+import { ROW_ID_FIELD } from './schema.js';
+import { isReservedTableName, isRowIdField } from './row.js';
+import { resolveFuncName } from '../functions/func-ref.js';
+import { buildDependencyGraph } from './deps.js';
+import { formatFieldPath, parseFieldPath } from './path.js';
+function isSessionTable(tableName, table) {
+    return tableName === 'session' && 'rows' in table && table.rows === 'single' && 'label' in table;
+}
+function toRuntimeField(field, functions) {
+    if (field.derived) {
+        return {
+            derived: true,
+            label: field.label,
+            dataType: field.dataType,
+            dependsOn: field.dependsOn,
+            computeFn: resolveFuncName(field.computeFn, functions),
+            deprecated: 'deprecated' in field ? field.deprecated : undefined,
+        };
+    }
+    return {
+        derived: false,
+        label: field.label,
+        dataType: field.dataType,
+        source: field.source,
+        extraction: field.extraction,
+        enum: field.enum,
+        nullable: field.nullable,
+        identifier: 'identifier' in field ? field.identifier : null,
+        ref: 'ref' in field && field.ref ? field.ref : null,
+        deprecated: 'deprecated' in field ? field.deprecated : undefined,
+    };
+}
+function applyFieldOverride(field, override) {
+    const next = { ...field };
+    if (override.label !== undefined)
+        next.label = override.label;
+    if (override.extraction !== undefined && !next.derived) {
+        next.extraction = override.extraction;
+    }
+    return next;
+}
+function isValidIdField(field) {
+    return (!!field && !field.derived && field.dataType === 'string' && field.source === 'system' && field.nullable === false);
+}
+function requireRowIdField(fields, path, issues) {
+    const existing = fields[ROW_ID_FIELD];
+    if (!existing) {
+        issues.push({
+            code: 'missing-id-field',
+            message: `${path} is required`,
+            path,
+        });
+        return;
+    }
+    if (!isValidIdField(existing)) {
+        issues.push({
+            code: 'invalid-id-field',
+            message: `${path} must be a non-null system string`,
+            path,
+        });
+    }
+}
+function validateCompanyRefs(company, issues) {
+    for (const [tableName, table] of Object.entries(company)) {
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            if (field.derived)
+                continue;
+            if (!field.ref)
+                continue;
+            const targetTable = field.ref.table;
+            if (isRowIdField(fieldName)) {
+                issues.push({
+                    code: 'id-cannot-ref',
+                    message: `${tableName}.${ROW_ID_FIELD} cannot be a ref`,
+                    path: formatFieldPath(tableName, fieldName),
+                });
+                continue;
+            }
+            if (!company[targetTable]) {
+                issues.push({
+                    code: 'unknown-ref-table',
+                    message: `ref table not in company schema: ${targetTable}`,
+                    path: formatFieldPath(tableName, fieldName),
+                });
+            }
+        }
+    }
+}
+/**
+ * Inherit every company table, then apply sequence overlays + session.
+ */
+export function compileSlotSchema(company, sequenceSlots, options = {}) {
+    const issues = [];
+    const tables = {};
+    if (!sequenceSlots.session) {
+        issues.push({
+            code: 'missing-session',
+            message: 'Sequence slots must define a session table',
+            path: 'session',
+        });
+    }
+    for (const [tableName, companyTable] of Object.entries(company)) {
+        if (tableName === 'session' || isReservedTableName(tableName)) {
+            if (isReservedTableName(tableName)) {
+                issues.push({
+                    code: 'reserved-table-name',
+                    message: `Table name is reserved: ${tableName}`,
+                    path: tableName,
+                });
+            }
+            continue;
+        }
+        const fields = {};
+        for (const [fieldName, field] of Object.entries(companyTable.fields)) {
+            fields[fieldName] = toRuntimeField(field, options.functions);
+        }
+        requireRowIdField(fields, formatFieldPath(tableName, ROW_ID_FIELD), issues);
+        tables[tableName] = {
+            label: companyTable.label,
+            rows: companyTable.rows,
+            description: companyTable.description,
+            fields,
+        };
+    }
+    for (const [tableName, tableView] of Object.entries(sequenceSlots)) {
+        if (isReservedTableName(tableName)) {
+            issues.push({
+                code: 'reserved-table-name',
+                message: `Table name is reserved: ${tableName}`,
+                path: tableName,
+            });
+            continue;
+        }
+        if (isSessionTable(tableName, tableView)) {
+            const fields = {};
+            for (const [fieldName, fieldDef] of Object.entries(tableView.fields)) {
+                if (fieldDef.derived) {
+                    issues.push({
+                        code: 'session-derived-forbidden',
+                        message: 'session table must not define derived fields',
+                        path: formatFieldPath('session', fieldName),
+                    });
+                    continue;
+                }
+                fields[fieldName] = toRuntimeField(fieldDef, options.functions);
+            }
+            requireRowIdField(fields, formatFieldPath('session', ROW_ID_FIELD), issues);
+            tables.session = {
+                label: tableView.label,
+                rows: 'single',
+                description: tableView.description,
+                fields,
+            };
+            continue;
+        }
+        const inherited = tables[tableName];
+        if (!inherited) {
+            issues.push({
+                code: 'unknown-table',
+                message: `Sequence overrides unknown table: ${tableName}`,
+                path: tableName,
+            });
+            continue;
+        }
+        for (const [fieldName, override] of Object.entries(tableView.fields)) {
+            const existing = inherited.fields[fieldName];
+            if (!existing) {
+                issues.push({
+                    code: 'unknown-field',
+                    message: `Sequence overrides unknown field: ${tableName}.${fieldName}`,
+                    path: formatFieldPath(tableName, fieldName),
+                });
+                continue;
+            }
+            inherited.fields[fieldName] = applyFieldOverride(existing, override);
+        }
+    }
+    validateCompanyRefs(company, issues);
+    // Validate derived placement + dependsOn existence
+    for (const [tableName, table] of Object.entries(tables)) {
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            const path = formatFieldPath(tableName, fieldName);
+            if (!field.derived)
+                continue;
+            if (table.rows === 'multi') {
+                issues.push({
+                    code: 'multi-derived-forbidden',
+                    message: `Derived fields are not allowed on multi-row tables: ${path}`,
+                    path,
+                });
+            }
+            if (tableName === 'session') {
+                issues.push({
+                    code: 'session-derived-forbidden',
+                    message: `Derived fields are not allowed on session: ${path}`,
+                    path,
+                });
+            }
+            if (options.computeFns && !options.computeFns.has(field.computeFn)) {
+                issues.push({
+                    code: 'missing-compute-fn',
+                    message: `computeFn not found: ${field.computeFn}`,
+                    path,
+                });
+            }
+            for (const dep of field.dependsOn) {
+                const parsed = parseFieldPath(dep);
+                if (!parsed) {
+                    issues.push({
+                        code: 'invalid-depends-on',
+                        message: `Invalid dependsOn path: ${dep}`,
+                        path,
+                    });
+                    continue;
+                }
+                const depTable = tables[parsed.table];
+                const depField = depTable?.fields[parsed.field];
+                if (!depTable || !depField) {
+                    issues.push({
+                        code: 'missing-depends-on',
+                        message: `dependsOn refers to unknown field: ${dep}`,
+                        path,
+                    });
+                }
+            }
+        }
+        // Enum / normal field shape checks
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            if (field.derived)
+                continue;
+            const path = formatFieldPath(tableName, fieldName);
+            if (field.enum) {
+                for (const member of field.enum) {
+                    const memberType = typeof member;
+                    if ((field.dataType === 'number' && memberType !== 'number') ||
+                        (field.dataType !== 'number' && field.dataType !== 'boolean' && memberType !== 'string') ||
+                        (field.dataType === 'boolean' && memberType !== 'boolean')) {
+                        issues.push({
+                            code: 'invalid-enum-member',
+                            message: `enum member ${String(member)} incompatible with dataType ${field.dataType}`,
+                            path,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const graph = buildDependencyGraph(tables);
+    issues.push(...graph.issues);
+    const schema = {
+        ...tables,
+        derivedOrder: graph.derivedOrder,
+        reverseDeps: graph.reverseDeps,
+    };
+    return {
+        schema,
+        validation: issues.length === 0 ? { ok: true } : { ok: false, issues },
+    };
+}
+/** Validate field paths exist on a compiled schema. */
+export function validateFieldRefs(schema, refs) {
+    const issues = [];
+    for (const ref of refs) {
+        const parsed = parseFieldPath(ref);
+        if (!parsed) {
+            issues.push({
+                code: 'invalid-field-path',
+                message: `Invalid field path: ${ref}`,
+                path: ref,
+            });
+            continue;
+        }
+        const field = getCompiledTable(schema, parsed.table)?.fields[parsed.field];
+        if (!field) {
+            issues.push({
+                code: 'unknown-field',
+                message: `Unknown field: ${ref}`,
+                path: ref,
+            });
+        }
+    }
+    return issues.length === 0 ? { ok: true } : { ok: false, issues };
+}
+export function getCompiledTable(schema, tableName) {
+    if (isReservedTableName(tableName))
+        return undefined;
+    const value = schema[tableName];
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !('fields' in value)) {
+        return undefined;
+    }
+    return value;
+}
+export function compiledTableEntries(schema) {
+    const out = [];
+    for (const key of Object.keys(schema)) {
+        const table = getCompiledTable(schema, key);
+        if (table)
+            out.push([key, table]);
+    }
+    return out;
+}
+/** Snapshot / SF presentation: single → field dict, multi → row array. */
+export function isSnapshotSingleRow(table) {
+    return table.rows === 'single';
+}
+/** Effective schema for Slots codegen (multi → array, single → dict). */
+export function toEffectiveSchema(compiled) {
+    const tables = {};
+    for (const [tableName, table] of compiledTableEntries(compiled)) {
+        const fields = {};
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            fields[fieldName] = {
+                dataType: field.dataType,
+                enum: field.derived ? null : field.enum,
+                nullable: field.derived ? true : field.nullable,
+                ref: field.derived ? null : (field.ref ?? null),
+            };
+        }
+        tables[tableName] = { rows: table.rows, fields };
+    }
+    return tables;
+}
+export function listConversationFields(schema) {
+    const out = [];
+    for (const [tableName, table] of compiledTableEntries(schema)) {
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            if (field.derived)
+                continue;
+            if (field.source !== 'conversation')
+                continue;
+            out.push(formatFieldPath(tableName, fieldName));
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=compile-schema.js.map