@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/slot/company-metadata.js

@@ -0,0 +1,536 @@
+import { nameProblem } from './naming.js';
+import { formatFieldPath } from './path.js';
+import { PLATFORM_CONTACT_FIELDS, PLATFORM_SESSION_FIELDS } from './platform-fields.js';
+import { isReservedTableName } from './row.js';
+import { OPTION_DATA_TYPES, REMOVED_ENUM_KEY, REMOVED_IDENTIFIER_KEY, REMOVED_NULLABLE_KEY, REMOVED_SOURCE_KEY, ROW_ID_FIELD, SCALAR_DATA_TYPES, sessionSchemaSchema } from './schema.js';
+export { PLATFORM_CONTACT_FIELDS, PLATFORM_SESSION_FIELDS } from './platform-fields.js';
+/** The one table every company has: the only thing the platform contacts (14-sequence-instance §5). */
+export const CONTACT_TABLE = 'contact';
+/** The conversation's table: its fields are the company's `schema/session.ts`; no company table has this name. */
+export const SESSION_TABLE = 'session';
+export const CONTACT_OPT_OUT_FIELDS = ['opted_out', 'call_opted_out', 'sms_opted_out', 'email_opted_out'];
+/** Platform limits (14-sequence-instance §16.1). */
+export const LIMITS = {
+    /** Longest parent chain: a table's parent's parent … at most this many hops to a table without one. */
+    parentDepth: 5,
+    /** An instance's `variables`, serialized, bytes. */
+    variablesBytes: 64 * 1024,
+    /** Company tables per company and environment (18-record-search-index §4.7). */
+    tables: 100,
+    /** Fields per table, platform fields included. */
+    fieldsPerTable: 300,
+    /** `options` of one `select` / `multi_select` field (a longer list is a table and a lookupRef). */
+    options: 200,
+    /** Characters of one option: a short code, not a sentence (its meaning goes in `extraction`). */
+    optionChars: 60,
+    /**
+     * A `string` value, UTF-8 bytes, as written and lower-cased: its index entries keep it whole, and a
+     * B-tree entry holds at most 2688 bytes of it; the rest is room for the entry's other columns (34 §2).
+     */
+    stringBytes: 2500,
+    /** A `text` value, UTF-8 bytes: the storage's bound, not a business one (34 §2). */
+    textBytes: 64 * 1024,
+    /** One row's stored data, serialized, UTF-8 bytes. */
+    rowDataBytes: 256 * 1024,
+};
+/**
+ * The policy ids a run can name, per layer: the values of the platform's run variables
+ * `responsePolicy`, `slotFillingPolicy` and `voice` (14 §4.4). Customers write them, so an id is only
+ * ever added; removing or renaming one breaks the companies that use it.
+ */
+export const POLICY_IDS = {
+    response: ['default'],
+    slotFilling: ['default'],
+    voice: ['default'],
+};
+/** Session fields with the platform's only: what a company without fields of its own declares. */
+export const PLATFORM_SESSION_SCHEMA = { fields: { ...PLATFORM_SESSION_FIELDS } };
+/** Each table's platform fields, with the name its issue codes use (`missing-platform-<name>-field`). */
+export const PLATFORM_TABLE_FIELDS = {
+    contact: { name: 'contact', fields: PLATFORM_CONTACT_FIELDS },
+};
+/**
+ * A company table other than `contact`: one the company defines whole. Every company table (contact
+ * included) is stored as `Record` rows; `session` is the sequence's, stored on the session.
+ */
+export function isCustomTable(tableName) {
+    return tableName !== CONTACT_TABLE && tableName !== SESSION_TABLE && !isReservedTableName(tableName);
+}
+/** A table whose rows are `Record` rows: every company table, contact included. */
+export function isRecordTable(tableName) {
+    return tableName !== SESSION_TABLE && !isReservedTableName(tableName);
+}
+/** A table's parent: the field name and the table it points at; null when it has none. */
+export function parentOf(table) {
+    if (!table)
+        return null;
+    for (const [field, def] of Object.entries(table.fields)) {
+        const ref = def.ref;
+        if (ref?.kind === 'parent')
+            return { field, table: ref.table };
+    }
+    return null;
+}
+/**
+ * Whether `fieldName` is the table's parent. Its value is the row's owner: filled by the platform or
+ * given once on insert, never written after, and stored as the row's parent edge in `RecordRef`, not
+ * in its data.
+ */
+export function isParentField(table, fieldName) {
+    return parentOf(table)?.field === fieldName;
+}
+/**
+ * Why `schema/session.ts` is not a session schema (11-remove-sequence-schema §3.1): its fields are
+ * simple values, with no `ref` (the session is related to no other table).
+ */
+export function sessionSchemaIssues(session) {
+    const issues = [];
+    const fields = session.fields;
+    if (fields && typeof fields === 'object') {
+        for (const [fieldName, field] of Object.entries(fields)) {
+            const path = formatFieldPath(SESSION_TABLE, fieldName);
+            if (fieldName === ROW_ID_FIELD) {
+                issues.push({ code: 'invalid-session-field', message: `schema/session.ts: ${path}: the name is reserved`, path });
+                continue;
+            }
+            if (!field || typeof field !== 'object')
+                continue;
+            if (Object.hasOwn(field, REMOVED_SOURCE_KEY))
+                issues.push(sourceRemovedIssue(path, 'schema/session.ts: '));
+            if (Object.hasOwn(field, REMOVED_NULLABLE_KEY))
+                issues.push(nullableRemovedIssue(path, 'schema/session.ts: '));
+            if (Object.hasOwn(field, REMOVED_IDENTIFIER_KEY))
+                issues.push(identifierRemovedIssue(path, 'schema/session.ts: '));
+            issues.push(...optionIssues(path, field, 'schema/session.ts: '));
+            if ('unique' in field) {
+                issues.push({ code: 'invalid-session-field', message: `schema/session.ts: ${path}: a session field cannot be unique (there is one session row per conversation)`, path });
+            }
+            if ('ref' in field) {
+                issues.push({
+                    code: 'invalid-session-field',
+                    message: `schema/session.ts: ${path}: a session field has no ref (the session is related to no other table)`,
+                    path,
+                });
+            }
+            if (field.dataType === 'contact_schedule') {
+                issues.push({
+                    code: 'invalid-session-field',
+                    message: `schema/session.ts: ${path}: a session field is a simple value (${SCALAR_DATA_TYPES.join(', ')})`,
+                    path,
+                });
+            }
+        }
+    }
+    if (issues.length > 0)
+        return issues;
+    for (const issue of sessionSchemaSchema.safeParse(session).error?.issues ?? []) {
+        const [, fieldName, ...rest] = issue.path.map(String);
+        const path = fieldName ? formatFieldPath(SESSION_TABLE, fieldName) : SESSION_TABLE;
+        issues.push({
+            code: 'invalid-session-field',
+            message: `schema/session.ts: ${[path, ...rest].join('.')}: ${issue.message}`,
+            path,
+        });
+    }
+    return issues;
+}
+/**
+ * A ref's `relatedName` (13-data-model-v1 §23.4 items 3 and 6): a name like any other, and one the
+ * target table does not already use: not one of its fields, not another ref's `relatedName` to it.
+ * The way back is a key of the target row, beside its fields.
+ */
+function relatedNameIssues(company) {
+    const issues = [];
+    const taken = new Map();
+    for (const [tableName, table] of Object.entries(company)) {
+        if (tableName === SESSION_TABLE || isReservedTableName(tableName))
+            continue;
+        for (const [fieldName, field] of Object.entries(table.fields ?? {})) {
+            const name = field?.ref?.relatedName;
+            if (name === undefined)
+                continue;
+            const path = formatFieldPath(tableName, fieldName);
+            const target = field.ref.table;
+            const problem = typeof name === 'string' ? nameProblem(name) : { code: 'invalid-name', reason: 'must be a string' };
+            if (problem) {
+                issues.push({ code: problem.code, message: `${path}: relatedName ${JSON.stringify(name)} is not a relation name: ${problem.reason}`, path });
+                continue;
+            }
+            const targetTable = Object.hasOwn(company, target) ? company[target] : undefined;
+            // The row id is the platform's, on every table: a field of it all the same.
+            if (targetTable && (name === ROW_ID_FIELD || Object.hasOwn(targetTable.fields ?? {}, name))) {
+                issues.push({ code: 'related-name-conflict', message: `${path}: relatedName ${name} is already a field of ${target}`, path });
+                continue;
+            }
+            const names = taken.get(target) ?? new Map();
+            const other = names.get(name);
+            if (other) {
+                issues.push({ code: 'related-name-conflict', message: `${path}: relatedName ${name} is already ${other}'s way back to ${target}`, path });
+                continue;
+            }
+            names.set(name, path);
+            taken.set(target, names);
+        }
+    }
+    return issues;
+}
+/**
+ * Names the schema may not use (13-data-model-v1 §23.4 item 6): every table name, field name and
+ * session field name is checked once here, for the whole company, not per sequence.
+ */
+function schemaNameIssues(company, session) {
+    const issues = [];
+    const check = (name, path, what) => {
+        const problem = nameProblem(name);
+        if (problem)
+            issues.push({ code: problem.code, message: `${path}: not a ${what} name: ${problem.reason}`, path });
+    };
+    for (const [tableName, table] of Object.entries(company)) {
+        if (tableName === SESSION_TABLE || isReservedTableName(tableName))
+            continue;
+        check(tableName, tableName, 'table');
+        for (const [fieldName, field] of Object.entries(table.fields ?? {})) {
+            const path = formatFieldPath(tableName, fieldName);
+            check(fieldName, path, 'field');
+            // A ref is the related row, its `.value` the id: named for the row (`injury`), not `injury_id` (§23.4 item 1).
+            if (field?.ref && fieldName.endsWith('_id')) {
+                const noun = fieldName.slice(0, -'_id'.length);
+                issues.push({
+                    code: 'ref-name-id-suffix',
+                    message: `${path}: a ref is named for the row it points at, without _id (e.g. ${noun}: ${field.ref.kind}Ref('${field.ref.table}'))`,
+                    path,
+                });
+            }
+        }
+    }
+    issues.push(...relatedNameIssues(company));
+    const sessionFields = session.fields;
+    if (sessionFields && typeof sessionFields === 'object') {
+        for (const fieldName of Object.keys(sessionFields)) {
+            if (fieldName === ROW_ID_FIELD)
+                continue; // `invalid-session-field` reports it
+            check(fieldName, formatFieldPath(SESSION_TABLE, fieldName), 'session field');
+        }
+    }
+    return issues;
+}
+/**
+ * Whether the company schema is one: its tables (`schema/index.ts`) and its session fields
+ * (`schema/session.ts`, the platform's only when the file is missing). `session` is reserved: no
+ * company table has the name. What a build stores is `compileSlotSchema`'s output.
+ */
+export function validateCompanySchema(company, session = PLATFORM_SESSION_SCHEMA) {
+    const issues = [];
+    if (Object.hasOwn(company, SESSION_TABLE)) {
+        issues.push({
+            code: 'reserved-table-name',
+            message: "Table name is reserved: session is the conversation's; define its fields in schema/session.ts",
+            path: SESSION_TABLE,
+        });
+    }
+    for (const tableName of Object.keys(company)) {
+        if (!isReservedTableName(tableName))
+            continue;
+        issues.push({ code: 'reserved-table-name', message: `Table name is reserved: ${tableName}`, path: tableName });
+    }
+    issues.push(...sessionSchemaIssues(session));
+    issues.push(...schemaNameIssues(company, session));
+    if (!Object.hasOwn(company, CONTACT_TABLE)) {
+        issues.push({
+            code: 'missing-contact-table',
+            message: 'the company schema must define the contact table (spread PLATFORM_CONTACT_FIELDS into it)',
+            path: CONTACT_TABLE,
+        });
+        return { ok: false, issues };
+    }
+    validatePlatformFields(company, CONTACT_TABLE, issues);
+    validatePlatformSessionFields(session, issues);
+    validateRelationships(company, issues);
+    issues.push(...fieldRuleIssues(company));
+    return issues.length === 0 ? { ok: true } : { ok: false, issues };
+}
+/**
+ * Relationship rules (14-sequence-instance §16.1): a table has at most one parent, a required system
+ * ref to another company table (not session, not itself); the parents form no cycle and no chain
+ * longer than {@link LIMITS.parentDepth}; `contact` has no parent (it belongs to no one thing). A
+ * ref no longer takes `unique` (13-data-model-v1 §22.4): a schema written before says so instead of
+ * silently getting a list.
+ */
+function validateRelationships(company, issues) {
+    const parentTargets = new Map();
+    for (const [tableName, table] of Object.entries(company)) {
+        if (tableName === SESSION_TABLE || isReservedTableName(tableName))
+            continue;
+        const parents = [];
+        for (const [fieldName, field] of Object.entries(table.fields)) {
+            if (!field.ref)
+                continue;
+            const path = formatFieldPath(tableName, fieldName);
+            const { ref } = field;
+            if ('unique' in ref) {
+                issues.push({
+                    code: 'unique-removed',
+                    message: `${path}: refs no longer take unique; a parent row has any number of rows under it (fields of one per parent belong on the parent table)`,
+                    path,
+                });
+            }
+            if (ref.kind !== 'parent')
+                continue;
+            parents.push(fieldName);
+            if (tableName === CONTACT_TABLE) {
+                issues.push({
+                    code: 'contact-parent-forbidden',
+                    message: `${path}: a contact belongs to no one row, so it has no parent; use lookupRef('${ref.table}') instead`,
+                    path,
+                });
+                continue;
+            }
+            if (ref.table === SESSION_TABLE || ref.table === tableName) {
+                issues.push({
+                    code: 'parent-target-invalid',
+                    message: `${path}: a parent must point at another company table, got ${ref.table}`,
+                    path,
+                });
+            }
+            else {
+                parentTargets.set(tableName, ref.table);
+            }
+        }
+        if (parents.length > 1) {
+            issues.push({
+                code: 'multiple-parents',
+                message: `${tableName} has more than one parent (${parents.join(', ')}); keep one and make the others lookups (lookupRef)`,
+                path: tableName,
+            });
+        }
+    }
+    for (const tableName of parentTargets.keys()) {
+        const seen = [tableName];
+        let next = parentTargets.get(tableName);
+        while (next !== undefined) {
+            if (seen.includes(next)) {
+                issues.push({
+                    code: 'parent-cycle',
+                    message: `${tableName}: its parents form a cycle (${[...seen, next].join(' → ')})`,
+                    path: tableName,
+                });
+                break;
+            }
+            seen.push(next);
+            next = parentTargets.get(next);
+        }
+        if (next === undefined && seen.length - 1 > LIMITS.parentDepth) {
+            issues.push({
+                code: 'parent-chain-too-long',
+                message: `${tableName}: its parent chain has ${seen.length - 1} levels (${seen.join(' → ')}); at most ${LIMITS.parentDepth}`,
+                path: tableName,
+            });
+        }
+    }
+}
+/** The issue for a field that still names its `source` (19-page-writable-cells). */
+export function sourceRemovedIssue(path, prefix = '') {
+    return {
+        code: 'source-removed',
+        message: `${prefix}${path}: remove source; a page decides what the AI may write (field(...) opens a cell, anything else on the page is read-only)`,
+        path,
+    };
+}
+/** The issue for a field that still names `nullable`, which no write checked. */
+export function nullableRemovedIssue(path, prefix = '') {
+    return {
+        code: 'nullable-removed',
+        message: `${prefix}${path}: remove nullable; every field starts empty and can be cleared (a page's required says when one must be filled)`,
+        path,
+    };
+}
+/** The issue for a field that still names `identifier`, which nothing used. */
+export function identifierRemovedIssue(path, prefix = '') {
+    return {
+        code: 'identifier-removed',
+        message: `${prefix}${path}: remove identifier; resolve.ts decides who a conversation is with (ctx.api.contact.find looks up phone and email)`,
+        path,
+    };
+}
+/**
+ * A field's choices (27 §2–§3): no `enum` (now a `select`); `options` on a `select` / `multi_select`
+ * only, and there required: 1 to `LIMITS.options` distinct short codes.
+ */
+export function optionIssues(path, field, prefix = '') {
+    const issues = [];
+    if (Object.hasOwn(field, REMOVED_ENUM_KEY)) {
+        issues.push({
+            code: 'enum-removed',
+            message: `${prefix}${path}: enum is removed; a field of a known set of values is dataType 'select' (one of them) or 'multi_select' (any of them) with options: [...]`,
+            path,
+        });
+    }
+    const options = field.options;
+    const takes = OPTION_DATA_TYPES.has(field.dataType);
+    if (!takes) {
+        if (options !== undefined) {
+            issues.push({ code: 'options-on-wrong-type', message: `${prefix}${path}: options are on a select or multi_select field only (this one is ${String(field.dataType)})`, path });
+        }
+        return issues;
+    }
+    if (!Array.isArray(options) || options.length === 0) {
+        issues.push({ code: 'missing-options', message: `${prefix}${path}: a ${String(field.dataType)} field needs options: [...] (at least one)`, path });
+        return issues;
+    }
+    if (options.length > LIMITS.options) {
+        issues.push({ code: 'too-many-options', message: `${prefix}${path}: ${options.length} options; at most ${LIMITS.options} (make it a table and a lookupRef instead)`, path });
+    }
+    const bad = options.filter((v) => typeof v !== 'string' || v.length === 0);
+    if (bad.length) {
+        issues.push({ code: 'invalid-option', message: `${prefix}${path}: options are non-empty strings (${bad.map((v) => JSON.stringify(v)).join(', ')})`, path });
+    }
+    const long = options.filter((v) => typeof v === 'string' && v.length > LIMITS.optionChars);
+    if (long.length) {
+        issues.push({
+            code: 'option-too-long',
+            message: `${prefix}${path}: options are short codes, at most ${LIMITS.optionChars} characters (${long.map((v) => JSON.stringify(v.slice(0, 30) + '…')).join(', ')}); say what each means in extraction`,
+            path,
+        });
+    }
+    const seen = new Set();
+    const repeated = options.filter((v) => (seen.has(v) ? true : (seen.add(v), false)));
+    if (repeated.length) {
+        issues.push({ code: 'duplicate-option', message: `${prefix}${path}: options repeat ${[...new Set(repeated)].map((v) => JSON.stringify(v)).join(', ')}`, path });
+    }
+    return issues;
+}
+/** The issue for a table that writes the row id, which is the platform's. */
+export function idIsPlatformIssue(path) {
+    return {
+        code: 'id-is-platform',
+        message: `${path}: remove id; every table has it (with createdAt and updatedAt), the platform's`,
+        path,
+    };
+}
+/** Types a `unique` field may have: values compared as one stored scalar (18-record-search-index §4.5). */
+const UNIQUE_DATA_TYPES = new Set(['string', 'phone', 'email', 'number']);
+/**
+ * Field and size rules (18-record-search-index §4.2, §4.5, §4.7): no `id` (the platform's), no
+ * `source`, `nullable`, `identifier` or `enum`; the table and field limits, a field's options; `unique` only on a plain
+ * value of a type compared as stored.
+ */
+function fieldRuleIssues(company) {
+    const issues = [];
+    const tables = Object.entries(company).filter(([tableName]) => tableName !== SESSION_TABLE && !isReservedTableName(tableName));
+    if (tables.length > LIMITS.tables) {
+        issues.push({ code: 'too-many-tables', message: `the company schema has ${tables.length} tables; at most ${LIMITS.tables}`, path: '' });
+    }
+    for (const [tableName, table] of tables) {
+        const fields = Object.entries(table.fields ?? {});
+        // The platform's row id counts too.
+        const count = fields.filter(([name]) => name !== ROW_ID_FIELD).length + 1;
+        if (count > LIMITS.fieldsPerTable) {
+            issues.push({ code: 'too-many-fields', message: `${tableName} has ${count} fields with its id; at most ${LIMITS.fieldsPerTable}`, path: tableName });
+        }
+        for (const [fieldName, field] of fields) {
+            if (!field || typeof field !== 'object')
+                continue;
+            const path = formatFieldPath(tableName, fieldName);
+            if (fieldName === ROW_ID_FIELD) {
+                issues.push(idIsPlatformIssue(path));
+                continue;
+            }
+            if (Object.hasOwn(field, REMOVED_SOURCE_KEY))
+                issues.push(sourceRemovedIssue(path));
+            if (Object.hasOwn(field, REMOVED_NULLABLE_KEY))
+                issues.push(nullableRemovedIssue(path));
+            if (Object.hasOwn(field, REMOVED_IDENTIFIER_KEY))
+                issues.push(identifierRemovedIssue(path));
+            issues.push(...optionIssues(path, field));
+            if (field.unique !== undefined) {
+                if (field.unique !== true || !UNIQUE_DATA_TYPES.has(field.dataType) || field.ref) {
+                    issues.push({
+                        code: 'invalid-unique',
+                        message: `${path}: unique is true or absent, on a string, phone, email or number field that is not a ref`,
+                        path,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/** Every platform field of `tableName` is in the company schema, defined as the runtime defines it. */
+function validatePlatformFields(company, tableName, issues) {
+    const platform = PLATFORM_TABLE_FIELDS[tableName];
+    for (const [name, required] of Object.entries(platform.fields)) {
+        const path = `${tableName}.${name}`;
+        const actual = company[tableName]?.fields[name];
+        if (!actual) {
+            issues.push({ code: `missing-platform-${platform.name}-field`, message: `${path} is required`, path });
+            continue;
+        }
+        const differing = differingProperties(actual, required);
+        if (differing.length > 0) {
+            issues.push({
+                code: `invalid-platform-${platform.name}-field`,
+                message: `${path} must match the runtime field definition; it differs in: ${differing.join(', ')}`,
+                path,
+            });
+        }
+    }
+}
+/** Every platform session field is in `schema/session.ts`, defined as the runtime defines it (24 §5.2). */
+function validatePlatformSessionFields(session, issues) {
+    for (const [name, required] of Object.entries(PLATFORM_SESSION_FIELDS)) {
+        const path = `${SESSION_TABLE}.${name}`;
+        const actual = session.fields?.[name];
+        if (!actual) {
+            issues.push({ code: 'missing-platform-session-field', message: `${path} is required: spread PLATFORM_SESSION_FIELDS into schema/session.ts`, path });
+            continue;
+        }
+        const differing = differingProperties(actual, required);
+        if (differing.length > 0) {
+            issues.push({ code: 'invalid-platform-session-field', message: `${path} must match the runtime field definition; it differs in: ${differing.join(', ')}`, path });
+        }
+    }
+}
+/** The company table a sequence names as its business root, checked (14 §4.5). */
+export function subjectTableIssues(company, subject) {
+    if (typeof subject !== 'string' || subject.length === 0) {
+        return [
+            {
+                code: 'missing-subject',
+                message: "the sequence must declare its business root: export default defineSequence({ subject: '<table>' }) in index.ts",
+                path: 'subject',
+            },
+        ];
+    }
+    if (subject === SESSION_TABLE || isReservedTableName(subject) || !Object.hasOwn(company, subject)) {
+        return [{ code: 'unknown-subject', message: `subject is not a company table: ${subject}`, path: 'subject' }];
+    }
+    return [];
+}
+/**
+ * The properties where an authored required field departs from its runtime definition, by value:
+ * key order never matters, and an `undefined` property or `deprecated: false` reads as absent
+ * (both mean the default). `deprecated: true` is a difference: a required field cannot be retired.
+ */
+function differingProperties(actual, required) {
+    const authored = presentProperties(actual);
+    const canonical = presentProperties(required);
+    const keys = [...new Set([...Object.keys(authored), ...Object.keys(canonical)])].sort();
+    return keys.filter((key) => !sameValue(authored[key], canonical[key]));
+}
+function presentProperties(field) {
+    return Object.fromEntries(Object.entries(field).filter(([key, value]) => value !== undefined && !(key === 'deprecated' && value === false)));
+}
+/** Deep equality of plain JSON values, ignoring object key order and `undefined` properties. */
+function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, i) => sameValue(item, b[i]));
+    }
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object')
+        return false;
+    const left = Object.entries(a).filter(([, value]) => value !== undefined);
+    const right = new Map(Object.entries(b).filter(([, value]) => value !== undefined));
+    return left.length === right.size && left.every(([key, value]) => right.has(key) && sameValue(value, right.get(key)));
+}
+//# sourceMappingURL=company-metadata.js.map

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

@@ -1,24 +1,30 @@
-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';
+import type { CompanyFieldDef, CompanySchema, SessionSchema } from './schema.js';
+import type { CompiledSlotSchema, RuntimeFieldDef, RuntimeTableDef, ValidationResult } from './types.js';
+export declare function companyFieldToRuntime(field: CompanyFieldDef): RuntimeFieldDef;
 /**
- * Inherit every company table, then apply sequence overlays + session.
+ * The company schema as the platform reads it (28 §2): every company table and field, and the
+ * company's session fields (`schema/session.ts`). One for the whole company: every sequence, page and
+ * function reads it; a sequence only names its `subject` (checked by `subjectTableIssues`).
  */
-export declare function compileSlotSchema(company: CompanySchema, sequenceSlots: SequenceSlots, options?: {
-    computeFns?: ReadonlySet<string>;
-    functions?: FuncMap;
+export declare function compileSlotSchema(company: CompanySchema, options?: {
+    /** The company's session fields (`schema/session.ts`); none when omitted. */
+    session?: SessionSchema;
 }): {
     schema: CompiledSlotSchema;
     validation: ValidationResult;
 };
 /** Validate field paths exist on a compiled schema. */
 export declare function validateFieldRefs(schema: CompiledSlotSchema, refs: Iterable<string>): ValidationResult;
+/** A way back to a table (13-data-model-v1 §23.4 item 3): the rows of `table` whose ref `field` points at it. */
+export type TableRelation = {
+    name: string;
+    table: string;
+    field: string;
+};
+/** The ways back to `tableName`: every ref of this schema that points at it and has a `relatedName`. */
+export declare function relationsOf(schema: CompiledSlotSchema, tableName: string): TableRelation[];
+/** A table's own field by name; undefined for any other key, a name every object has (`toString`) included. */
+export declare function getTableField(table: Pick<RuntimeTableDef, 'fields'>, fieldName: string): RuntimeFieldDef | undefined;
 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