@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/core/context/hubspot.js

@@ -1,191 +0,0 @@
-import { z } from 'zod';
-export const hubspotPropertyValue = z.union([z.string(), z.number(), z.boolean()]);
-export const hubspotPropertiesInput = z.record(z.string(), hubspotPropertyValue);
-export const hubspotPropertiesOutput = z.record(z.string(), z.string().nullable());
-export const hubspotRecord = z.object({
-    id: z.string(),
-    properties: hubspotPropertiesOutput,
-});
-export const hubspotCreateContactInput = z.object({
-    properties: hubspotPropertiesInput,
-});
-export const hubspotCreateContactOutput = hubspotRecord;
-export const hubspotUpdateContactInput = z.object({
-    id: z.string(),
-    properties: hubspotPropertiesInput,
-});
-export const hubspotUpdateContactOutput = hubspotRecord;
-export const hubspotGetContactInput = z.object({
-    id: z.string(),
-    properties: z.array(z.string()).optional(),
-});
-export const hubspotGetContactOutput = hubspotRecord;
-export const hubspotSearchContactsInput = z.object({
-    query: z.string(),
-    properties: z.array(z.string()).optional(),
-    after: z.string().optional(),
-});
-export const hubspotSearchContactsOutput = z.object({
-    total: z.number(),
-    results: z.array(hubspotRecord),
-    after: z.string().optional(),
-});
-export const hubspotUpsertContactInput = z.object({
-    email: z.string(),
-    properties: hubspotPropertiesInput.optional(),
-});
-export const hubspotUpsertContactOutput = z.object({
-    ok: z.literal(true),
-    id: z.string(),
-    created: z.boolean(),
-});
-export const hubspotCreateDealInput = z.object({
-    properties: hubspotPropertiesInput,
-    contactId: z.string().optional(),
-});
-export const hubspotCreateDealOutput = hubspotRecord;
-export const hubspotUpdateDealInput = z.object({
-    id: z.string(),
-    properties: hubspotPropertiesInput,
-});
-export const hubspotUpdateDealOutput = hubspotRecord;
-export const hubspotGetDealInput = z.object({
-    id: z.string(),
-    properties: z.array(z.string()).optional(),
-});
-export const hubspotGetDealOutput = hubspotRecord;
-export const hubspotGetAssociatedDealsInput = z.object({
-    contactId: z.string(),
-});
-export const hubspotAssociationListOutput = z.object({
-    results: z.array(z.object({ id: z.string() })),
-});
-export const hubspotGetAssociatedContactsInput = z.object({
-    dealId: z.string(),
-});
-export const hubspotGetOwnerInput = z.object({
-    id: z.string(),
-});
-export const hubspotGetOwnerOutput = z.object({
-    id: z.string(),
-    email: z.string().nullable(),
-    firstName: z.string().nullable(),
-    lastName: z.string().nullable(),
-});
-export const hubspotCreateNoteInput = z.object({
-    contactId: z.string(),
-    body: z.string(),
-});
-export const hubspotEngagementOutput = z.object({
-    id: z.string(),
-});
-const hubspotAssociateTo = z.object({
-    kind: z.enum(['contact', 'deal']),
-    id: z.string(),
-});
-export const hubspotLogCallInput = z.object({
-    to: hubspotAssociateTo,
-    direction: z.enum(['INBOUND', 'OUTBOUND']),
-    timestamp: z.number(),
-    title: z.string().optional(),
-    body: z.string().optional(),
-    recordingUrl: z.string().optional(),
-    status: z
-        .enum([
-        'BUSY',
-        'CALLING_CRM_USER',
-        'CANCELED',
-        'COMPLETED',
-        'CONNECTING',
-        'FAILED',
-        'IN_PROGRESS',
-        'NO_ANSWER',
-        'QUEUED',
-        'RINGING',
-    ])
-        .optional(),
-});
-export const hubspotLogEmailInput = z.object({
-    to: hubspotAssociateTo,
-    direction: z.enum(['EMAIL', 'INCOMING_EMAIL', 'FORWARDED_EMAIL']),
-    subject: z.string(),
-    body: z.string(),
-    timestamp: z.number(),
-});
-export const hubspotLogSmsInput = z.object({
-    to: hubspotAssociateTo,
-    message: z.string(),
-    timestamp: z.number(),
-    prefix: z.string().optional(),
-});
-export const hubspotCreateTaskInput = z.object({
-    to: hubspotAssociateTo,
-    title: z.string(),
-    description: z.string(),
-    dueAt: z.number(),
-    ownerId: z.string(),
-    priority: z.enum(['HIGH', 'MEDIUM', 'LOW']),
-    status: z.enum(['NOT_STARTED', 'IN_PROGRESS', 'WAITING', 'COMPLETED', 'DEFERRED']),
-});
-export const hubspotGetCrmUrlInput = z.object({
-    type: z.enum(['contact', 'call']),
-    id: z.string(),
-});
-export const hubspotGetCrmUrlOutput = z.object({
-    url: z.string(),
-});
-const mockRecord = { id: 'mock-hs-1', properties: {} };
-export const hubspotMockService = {
-    async createContact() {
-        return mockRecord;
-    },
-    async updateContact() {
-        return mockRecord;
-    },
-    async getContact() {
-        return mockRecord;
-    },
-    async searchContacts() {
-        return { total: 0, results: [] };
-    },
-    async upsertContact() {
-        return { ok: true, id: 'mock-hs-1', created: true };
-    },
-    async createDeal() {
-        return mockRecord;
-    },
-    async updateDeal() {
-        return mockRecord;
-    },
-    async getDeal() {
-        return mockRecord;
-    },
-    async getAssociatedDeals() {
-        return { results: [] };
-    },
-    async getAssociatedContacts() {
-        return { results: [] };
-    },
-    async getOwner() {
-        return { id: 'mock-owner', email: null, firstName: null, lastName: null };
-    },
-    async createNote() {
-        return { id: 'mock-note' };
-    },
-    async logCall() {
-        return { id: 'mock-call' };
-    },
-    async logEmail() {
-        return { id: 'mock-email' };
-    },
-    async logSms() {
-        return { id: 'mock-sms' };
-    },
-    async createTask() {
-        return { id: 'mock-task' };
-    },
-    async getCrmUrl() {
-        return { url: 'https://app.hubspot.com/contacts/0/record/0-1/mock-hs-1' };
-    },
-};
-//# sourceMappingURL=hubspot.js.map

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

@@ -1,50 +0,0 @@
-import { z } from 'zod';
-import type { IntegrationAccountFields } from './account-fields.js';
-export declare const twilioSendSmsInput: z.ZodObject<{
-    to: z.ZodString;
-    body: z.ZodString;
-    from: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TwilioSendSmsInput = z.infer<typeof twilioSendSmsInput>;
-export declare const twilioSendSmsOutput: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    sid: z.ZodString;
-    status: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type TwilioSendSmsOutput = z.infer<typeof twilioSendSmsOutput>;
-export declare const twilioCreateCallInput: z.ZodObject<{
-    to: z.ZodString;
-    from: z.ZodString;
-    url: z.ZodOptional<z.ZodString>;
-    twiml: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TwilioCreateCallInput = z.infer<typeof twilioCreateCallInput>;
-export declare const twilioCreateCallOutput: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    sid: z.ZodString;
-    status: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type TwilioCreateCallOutput = z.infer<typeof twilioCreateCallOutput>;
-export declare const twilioIncomingNumber: z.ZodObject<{
-    sid: z.ZodString;
-    phoneNumber: z.ZodString;
-    friendlyName: z.ZodString;
-    status: z.ZodString;
-}, z.core.$strip>;
-export type TwilioIncomingNumber = z.infer<typeof twilioIncomingNumber>;
-export declare const twilioListIncomingNumbersOutput: z.ZodArray<z.ZodObject<{
-    sid: z.ZodString;
-    phoneNumber: z.ZodString;
-    friendlyName: z.ZodString;
-    status: z.ZodString;
-}, z.core.$strip>>;
-export type TwilioListIncomingNumbersOutput = z.infer<typeof twilioListIncomingNumbersOutput>;
-export type TwilioService = {
-    sendSms(input: TwilioSendSmsInput): Promise<TwilioSendSmsOutput>;
-    createCall(input: TwilioCreateCallInput): Promise<TwilioCreateCallOutput>;
-    listIncomingNumbers(): Promise<TwilioListIncomingNumbersOutput>;
-};
-/** Stand-in surface for fake contexts and local runs; never reaches Twilio. */
-export declare const twilioMockService: TwilioService;
-export type TwilioApi = IntegrationAccountFields & TwilioService;
-//# sourceMappingURL=twilio.d.ts.map

package/dist/core/context/twilio.js

@@ -1,42 +0,0 @@
-import { z } from 'zod';
-export const twilioSendSmsInput = z.object({
-    to: z.string(),
-    body: z.string(),
-    from: z.string().optional(),
-});
-export const twilioSendSmsOutput = z.object({
-    ok: z.literal(true),
-    sid: z.string(),
-    status: z.string().nullable(),
-});
-export const twilioCreateCallInput = z.object({
-    to: z.string(),
-    from: z.string(),
-    url: z.string().optional(),
-    twiml: z.string().optional(),
-});
-export const twilioCreateCallOutput = z.object({
-    ok: z.literal(true),
-    sid: z.string(),
-    status: z.string().nullable(),
-});
-export const twilioIncomingNumber = z.object({
-    sid: z.string(),
-    phoneNumber: z.string(),
-    friendlyName: z.string(),
-    status: z.string(),
-});
-export const twilioListIncomingNumbersOutput = z.array(twilioIncomingNumber);
-/** Stand-in surface for fake contexts and local runs; never reaches Twilio. */
-export const twilioMockService = {
-    async sendSms() {
-        return { ok: true, sid: 'SM-mock', status: 'queued' };
-    },
-    async createCall() {
-        return { ok: true, sid: 'CA-mock', status: 'queued' };
-    },
-    async listIncomingNumbers() {
-        return [];
-    },
-};
-//# sourceMappingURL=twilio.js.map

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

@@ -1,14 +0,0 @@
-/** `(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

@@ -1,15 +0,0 @@
-/** 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

@@ -1,7 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/** 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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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/slot/deps.d.ts

@@ -1,15 +0,0 @@
-import type { FieldPath } from './path.js';
-import type { RuntimeTableDef, ValidationIssue } from './types.js';
-export type DependencyGraphResult = {
-    derivedOrder: FieldPath[];
-    reverseDeps: Record<FieldPath, FieldPath[]>;
-    issues: ValidationIssue[];
-};
-/**
- * Build topological order of derived fields and reverse dependency index.
- * Reports cycles instead of throwing.
- */
-export declare function buildDependencyGraph(tables: Record<string, RuntimeTableDef>): DependencyGraphResult;
-/** Collect derived fields affected by changed columns, in topo order. */
-export declare function affectedDerivedFields(changed: Iterable<FieldPath>, reverseDeps: Record<FieldPath, FieldPath[]>, derivedOrder: FieldPath[]): FieldPath[];
-//# sourceMappingURL=deps.d.ts.map

package/dist/core/slot/deps.js

@@ -1,88 +0,0 @@
-import { formatFieldPath, parseFieldPath } from './path.js';
-/**
- * Build topological order of derived fields and reverse dependency index.
- * Reports cycles instead of throwing.
- */
-export function buildDependencyGraph(tables) {
-    const issues = [];
-    const derivedPaths = [];
-    const edges = new Map();
-    const reverseDeps = {};
-    for (const [tableName, table] of Object.entries(tables)) {
-        for (const [fieldName, field] of Object.entries(table.fields)) {
-            if (!field.derived)
-                continue;
-            const path = formatFieldPath(tableName, fieldName);
-            derivedPaths.push(path);
-            const deps = [];
-            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;
-                }
-                deps.push(parsed.path);
-                if (!reverseDeps[parsed.path])
-                    reverseDeps[parsed.path] = [];
-                reverseDeps[parsed.path].push(path);
-            }
-            edges.set(path, deps);
-        }
-    }
-    // Kahn topological sort over derived nodes only; edges point to dependencies.
-    const indegree = new Map();
-    const dependents = new Map();
-    for (const path of derivedPaths) {
-        indegree.set(path, 0);
-        dependents.set(path, []);
-    }
-    for (const [path, deps] of edges) {
-        for (const dep of deps) {
-            if (!indegree.has(dep))
-                continue; // dependency is a normal field
-            indegree.set(path, (indegree.get(path) ?? 0) + 1);
-            dependents.get(dep).push(path);
-        }
-    }
-    const queue = derivedPaths.filter((p) => (indegree.get(p) ?? 0) === 0);
-    const derivedOrder = [];
-    while (queue.length > 0) {
-        const path = queue.shift();
-        derivedOrder.push(path);
-        for (const next of dependents.get(path) ?? []) {
-            const nextDeg = (indegree.get(next) ?? 0) - 1;
-            indegree.set(next, nextDeg);
-            if (nextDeg === 0)
-                queue.push(next);
-        }
-    }
-    if (derivedOrder.length !== derivedPaths.length) {
-        const remaining = derivedPaths.filter((p) => !derivedOrder.includes(p));
-        issues.push({
-            code: 'cyclic-dependency',
-            message: `Cyclic derived dependency involving: ${remaining.join(' → ')}`,
-            path: remaining[0],
-        });
-    }
-    return { derivedOrder, reverseDeps, issues };
-}
-/** Collect derived fields affected by changed columns, in topo order. */
-export function affectedDerivedFields(changed, reverseDeps, derivedOrder) {
-    const hit = new Set();
-    const stack = [...changed];
-    while (stack.length > 0) {
-        const path = stack.pop();
-        for (const derived of reverseDeps[path] ?? []) {
-            if (hit.has(derived))
-                continue;
-            hit.add(derived);
-            stack.push(derived);
-        }
-    }
-    return derivedOrder.filter((path) => hit.has(path));
-}
-//# sourceMappingURL=deps.js.map

package/dist/core/slot/derived.d.ts

@@ -1,32 +0,0 @@
-import type { Writes } from '../context/types.js';
-import type { FieldPath } from './path.js';
-import type { ApplyWritesOptions, CompiledSlotSchema, RecomputeResult, RuntimeSlotsSnapshot, SlotFillingOutput } from './types.js';
-import { createLocalComputeHost, resolveComputeHost, type ComputeFnMap, type ComputeHost, type ComputeHostOrFns, type LocalComputeHostOptions } from '../../compute-host/compute-host.js';
-import { createSourceComputeHost } from '../../compute-host/source-compute-host.js';
-import { type ApplySlotFillingOptions, type FieldPatchInput } from './write.js';
-export type { ComputeFnMap, ComputeHost, ComputeHostOrFns, LocalComputeHostOptions };
-export { createLocalComputeHost, createSourceComputeHost, resolveComputeHost };
-export type RecomputeOptions = {
-    now?: number;
-    /**
-     * When true, recompute every derived field in topo order (session start heal).
-     * When false (default), only fields affected by `changed`.
-     */
-    all?: boolean;
-    changed?: Iterable<FieldPath>;
-};
-/**
- * C6: recompute derived fields in topological order via {@link ComputeHost}.
- * `null` return means no conclusion yet (stored as filled+null).
- */
-export declare function recomputeDerived(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, hostOrFns: ComputeHostOrFns, options?: RecomputeOptions): Promise<RecomputeResult>;
-/** C4→C6: apply normal writes then recompute affected derived fields. */
-export declare function applyWritesAndRecompute(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, writes: Writes | null | undefined, hostOrFns: ComputeHostOrFns, writeOptions: ApplyWritesOptions): Promise<RecomputeResult>;
-/** Apply an explicit-state field edit, then recompute every affected derived field. */
-export declare function applyFieldPatchAndRecompute(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, patch: FieldPatchInput, hostOrFns: ComputeHostOrFns, options: {
-    source: ApplyWritesOptions['source'];
-    now?: number;
-}): Promise<RecomputeResult>;
-/** C4→C6 for accepted Slot Filling output. */
-export declare function applySlotFillingAndRecompute(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, output: SlotFillingOutput, hostOrFns: ComputeHostOrFns, options?: ApplySlotFillingOptions): Promise<RecomputeResult>;
-//# sourceMappingURL=derived.d.ts.map

package/dist/core/slot/derived.js

@@ -1,115 +0,0 @@
-import { getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { createLocalComputeHost, resolveComputeHost, } from '../../compute-host/compute-host.js';
-import { createSourceComputeHost } from '../../compute-host/source-compute-host.js';
-import { affectedDerivedFields } from './deps.js';
-import { commitFieldWrite, makeFieldValue } from './field.js';
-import { requireFieldPath } from './path.js';
-import { getRowField } from './row.js';
-import { cloneSnapshot, getSnapshotTable } from './snapshot.js';
-import { validateBareValue } from './value.js';
-import { applyFieldPatch, applySlotFilling, applyWrites, } from './write.js';
-export { createLocalComputeHost, createSourceComputeHost, resolveComputeHost };
-/**
- * C6: recompute derived fields in topological order via {@link ComputeHost}.
- * `null` return means no conclusion yet (stored as filled+null).
- */
-export async function recomputeDerived(schema, snapshot, hostOrFns, options = {}) {
-    const host = resolveComputeHost(hostOrFns);
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changedOut = [];
-    const history = [];
-    const targets = options.all
-        ? schema.derivedOrder
-        : affectedDerivedFields(options.changed ?? [], schema.reverseDeps, schema.derivedOrder);
-    for (const path of targets) {
-        const parsed = requireFieldPath(path);
-        const table = getCompiledTable(schema, parsed.table);
-        const field = table?.fields[parsed.field];
-        if (!table || !field || !field.derived)
-            continue;
-        if (!isSnapshotSingleRow(table))
-            continue;
-        const raw = await host.execute(field.computeFn, [next]);
-        const issues = validateBareValue(field, raw, path, { allowNull: true });
-        if (issues.length > 0) {
-            throw new Error(`Derived ${path} returned invalid value: ${issues.map((i) => i.message).join('; ')}`);
-        }
-        const tableData = getSnapshotTable(next, parsed.table);
-        const prev = getRowField(tableData, parsed.field);
-        if (!prev)
-            continue;
-        const committed = commitFieldWrite(prev, makeFieldValue({
-            value: (raw ?? null),
-            state: 'filled',
-            reason: null,
-            updatedBy: 'derived',
-            updatedAt: now,
-        }));
-        tableData[parsed.field] = committed.field;
-        if (committed.changed) {
-            changedOut.push(path);
-            if (committed.historyEntry) {
-                history.push({ path, entry: committed.historyEntry });
-            }
-        }
-    }
-    return { snapshot: next, changed: changedOut, history };
-}
-/** C4→C6: apply normal writes then recompute affected derived fields. */
-export async function applyWritesAndRecompute(schema, snapshot, writes, hostOrFns, writeOptions) {
-    const applied = applyWrites(schema, snapshot, writes, writeOptions);
-    if (applied.changed.length === 0) {
-        return {
-            snapshot: applied.snapshot,
-            changed: [],
-            history: applied.history,
-        };
-    }
-    const recomputed = await recomputeDerived(schema, applied.snapshot, hostOrFns, {
-        now: writeOptions.now,
-        changed: applied.changed,
-    });
-    return {
-        snapshot: recomputed.snapshot,
-        changed: [...applied.changed, ...recomputed.changed],
-        history: [...applied.history, ...recomputed.history],
-    };
-}
-/** Apply an explicit-state field edit, then recompute every affected derived field. */
-export async function applyFieldPatchAndRecompute(schema, snapshot, patch, hostOrFns, options) {
-    const applied = applyFieldPatch(schema, snapshot, patch, options);
-    if (applied.changed.length === 0) {
-        return { snapshot: applied.snapshot, changed: [], history: applied.history };
-    }
-    const recomputed = await recomputeDerived(schema, applied.snapshot, hostOrFns, {
-        now: options.now,
-        changed: applied.changed,
-    });
-    return {
-        snapshot: recomputed.snapshot,
-        changed: [...applied.changed, ...recomputed.changed],
-        history: [...applied.history, ...recomputed.history],
-    };
-}
-/** C4→C6 for accepted Slot Filling output. */
-export async function applySlotFillingAndRecompute(schema, snapshot, output, hostOrFns, options = {}) {
-    const applied = applySlotFilling(schema, snapshot, output, options);
-    if (applied.changed.length === 0) {
-        return {
-            snapshot: applied.snapshot,
-            changed: [],
-            history: applied.history,
-        };
-    }
-    const recomputed = await recomputeDerived(schema, applied.snapshot, hostOrFns, {
-        now: options.now,
-        changed: applied.changed,
-    });
-    return {
-        snapshot: recomputed.snapshot,
-        changed: [...applied.changed, ...recomputed.changed],
-        history: [...applied.history, ...recomputed.history],
-    };
-}
-//# sourceMappingURL=derived.js.map

package/dist/core/slot/platform-session-fields.d.ts

@@ -1,38 +0,0 @@
-import type { RuntimeTableDef } from './types.js';
-export declare const PLATFORM_SESSION_FIELDS: {
-    readonly is_inbound_call: {
-        readonly derived: false;
-        readonly label: 'Inbound call';
-        readonly dataType: 'boolean';
-        readonly source: 'system';
-        readonly extraction: 'Set by the conversation entry pipeline';
-        readonly enum: null;
-        readonly nullable: false;
-        readonly identifier: null;
-        readonly ref: null;
-    };
-    readonly is_first_call: {
-        readonly derived: false;
-        readonly label: 'First call';
-        readonly dataType: 'boolean';
-        readonly source: 'system';
-        readonly extraction: 'No prior session for this case contact';
-        readonly enum: null;
-        readonly nullable: false;
-        readonly identifier: null;
-        readonly ref: null;
-    };
-    readonly is_new_user: {
-        readonly derived: false;
-        readonly label: 'New user';
-        readonly dataType: 'boolean';
-        readonly source: 'system';
-        readonly extraction: 'No existing contact for this party';
-        readonly enum: null;
-        readonly nullable: false;
-        readonly identifier: null;
-        readonly ref: null;
-    };
-};
-export declare function createPlatformSessionTable(): RuntimeTableDef;
-//# sourceMappingURL=platform-session-fields.d.ts.map