@superpanel-sdk/runtime 0.2.3 → 0.7.0

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

@@ -0,0 +1,35 @@
+import type { Ctx } from '../functions/types.js';
+import type { PageTablesDesc } from '../page/typed.js';
+import type { CompanyResolveInput, CompanyResolveResult, ResolveInput, ResolveResult } from './schema.js';
+/**
+ * Who an inbound conversation goes to is decided in two steps (14-sequence-instance §18): the company
+ * repo's root `resolve.ts` picks the sequence, then that sequence's `sequences/<id>/resolve.ts` picks
+ * the instance of it (an active one, or a new one). Both export `resolve`.
+ */
+export declare const RESOLVE_MODULE = "resolve";
+/** Reserved export of `resolve.ts` and its name in the build's `functions`. */
+export declare const RESOLVE_FUNCTION = "resolve";
+/** `ctx.meta.entry` / RunScope entry of a `resolve` call. */
+export declare const RESOLVE_ENTRY = "resolve";
+/** The company `resolve.ts` compiled into every sequence's build, under this reserved name (§18.2). */
+export declare const COMPANY_RESOLVE_FUNCTION = "companyResolve";
+/** `ctx.meta.entry` / RunScope entry of a company `resolve` call. */
+export declare const COMPANY_RESOLVE_ENTRY = "companyResolve";
+/**
+ * The company `resolve.ts` (§18.2): `export const resolve: CompanyResolve = async (ctx, conversation) => …`. Runs for
+ * inbound calls, texts and emails only, before the sequence is known: returns `{ sequence }` (a name)
+ * or `{ decline: { reply? } }`. It reads with `ctx.api` like any function; the repository root's
+ * `__gen/` binds `D` to the company's tables, so `ctx.api.db` is typed.
+ */
+export type CompanyResolve<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, conversation: CompanyResolveInput) => Promise<CompanyResolveResult>;
+/**
+ * `sequences/<id>/resolve.ts`: `export const resolve: Resolve = async (ctx, conversation) => …`, with
+ * `Resolve` imported from the sequence's `__gen`. It finds and creates through `ctx.api.contact`, reads
+ * and writes records through `ctx.api.db`, finds instances through `ctx.api.instances` and exchanges
+ * through `ctx.api.exchanges`. The conversation in, `{ contactId,
+ * instanceId }` or `{ contactId, start }` out, on this sequence only. The platform gives it what is
+ * left of the time limit, checks the ids (an active instance of this sequence, a contact, a row of
+ * its subject table, all of this company and environment), and fails the conversation when not.
+ */
+export type Resolve<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, conversation: ResolveInput) => Promise<ResolveResult>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/party/types.js

@@ -0,0 +1,15 @@
+/**
+ * Who an inbound conversation goes to is decided in two steps (14-sequence-instance §18): the company
+ * repo's root `resolve.ts` picks the sequence, then that sequence's `sequences/<id>/resolve.ts` picks
+ * the instance of it (an active one, or a new one). Both export `resolve`.
+ */
+export const RESOLVE_MODULE = 'resolve';
+/** Reserved export of `resolve.ts` and its name in the build's `functions`. */
+export const RESOLVE_FUNCTION = 'resolve';
+/** `ctx.meta.entry` / RunScope entry of a `resolve` call. */
+export const RESOLVE_ENTRY = 'resolve';
+/** The company `resolve.ts` compiled into every sequence's build, under this reserved name (§18.2). */
+export const COMPANY_RESOLVE_FUNCTION = 'companyResolve';
+/** `ctx.meta.entry` / RunScope entry of a company `resolve` call. */
+export const COMPANY_RESOLVE_ENTRY = 'companyResolve';
+//# sourceMappingURL=types.js.map

package/dist/core/sequence/define.d.ts

@@ -0,0 +1,56 @@
+/**
+ * What a sequence's `index.ts` and `variables.ts` declare with (14-sequence-instance §4.4–§4.5). Part of
+ * the company API (`src/index.ts`), so it imports nothing: the checks live in `./index.ts`.
+ */
+/** `sequences/<id>/index.ts` default export. */
+export type SequenceDefinition<S extends string = string> = {
+    /** `label`: the name people see; without it, the directory name, which is the sequence's name. */
+    meta?: {
+        label?: string;
+    };
+    /** The company table each run is about: one row of it is the instance's business root. */
+    subject: S;
+};
+export declare function defineSequence<const S extends string>(definition: SequenceDefinition<S>): SequenceDefinition<S>;
+/** A JSON variable's marker; the type argument is only an editor hint (the platform checks it serializes). */
+export type JsonVariableType<T = unknown> = {
+    readonly kind: 'json';
+    readonly __type?: T;
+};
+export declare function json<T = unknown>(): JsonVariableType<T>;
+/** One run variable as declared. */
+export type VariableDecl = {
+    options: readonly (string | number | boolean)[];
+    default?: string | number | boolean | null;
+} | {
+    type: 'string';
+    default?: string | null;
+} | {
+    type: 'number';
+    default?: number | null;
+} | {
+    type: 'boolean';
+    default?: boolean | null;
+} | {
+    type: JsonVariableType;
+    default?: unknown;
+};
+export type VariableDecls = Record<string, VariableDecl>;
+export declare function defineVariables<const V extends VariableDecls>(variables: V): V;
+type VariableValue<D> = D extends {
+    options: readonly (infer O)[];
+} ? O : D extends {
+    type: 'string';
+} ? string : D extends {
+    type: 'number';
+} ? number : D extends {
+    type: 'boolean';
+} ? boolean : D extends {
+    type: JsonVariableType<infer T>;
+} ? T : never;
+/** The values of a `defineVariables` declaration, by name (null when unset and without a default). */
+export type VariablesOf<V> = {
+    [K in keyof V]: VariableValue<V[K]> | null;
+};
+export {};
+//# sourceMappingURL=define.d.ts.map

package/dist/core/sequence/define.js

@@ -0,0 +1,10 @@
+export function defineSequence(definition) {
+    return definition;
+}
+export function json() {
+    return { kind: 'json' };
+}
+export function defineVariables(variables) {
+    return variables;
+}
+//# sourceMappingURL=define.js.map

package/dist/core/sequence/index.d.ts

@@ -0,0 +1,63 @@
+export { defineSequence, defineVariables, json, type JsonVariableType, type SequenceDefinition, type VariableDecl, type VariableDecls, type VariablesOf, } from './define.js';
+/** One experiment: an enum variable and the share each of its values gets when a run does not set it. */
+export type ExperimentDecl = {
+    variable: string;
+    split: Record<string, number>;
+};
+/** `SequenceBuild.variables`: every declared variable, normalized. */
+export type CompiledVariable = {
+    type: 'enum';
+    options: Array<string | number | boolean>;
+    default: string | number | boolean | null;
+} | {
+    type: 'string';
+    default: string | null;
+} | {
+    type: 'number';
+    default: number | null;
+} | {
+    type: 'boolean';
+    default: boolean | null;
+} | {
+    type: 'json';
+    default: unknown;
+};
+export type CompiledVariables = Record<string, CompiledVariable>;
+export type CompiledExperiments = Record<string, ExperimentDecl>;
+/**
+ * Run variable names the platform reserves (14 §4.4). It reads `voice` when it opens a session;
+ * `responsePolicy` and `slotFillingPolicy` are reserved and not read yet. A sequence may leave them
+ * out (the platform default) or declare them as enums whose values the platform knows.
+ */
+export declare const SYSTEM_VARIABLES: readonly ['responsePolicy', 'slotFillingPolicy', 'voice'];
+export type SystemVariableName = (typeof SYSTEM_VARIABLES)[number];
+export declare function isSystemVariable(name: string): name is SystemVariableName;
+export type CompileVariablesResult = {
+    variables: CompiledVariables;
+    experiments: CompiledExperiments;
+    issues: string[];
+};
+/** Normalize and check a sequence's `variables.ts` (14 §4.4). */
+export declare function compileVariables(declared: unknown, experiments: unknown): CompileVariablesResult;
+/** Why `value` cannot be stored in the variable; null when it can. `null` always can (unset). */
+export declare function variableValueIssue(name: string, variable: CompiledVariable | undefined, value: unknown): string | null;
+/** Issues of a whole write of variables (unknown names, wrong types); empty when it may be stored. */
+export declare function variablesWriteIssues(variables: CompiledVariables, values: Record<string, unknown>): string[];
+/**
+ * The variables a new run starts with: every declared default, then the values given, then each
+ * experiment whose variable was not given assigns a value by `hash(instanceId + experiment)`, so the
+ * same instance always lands in the same group (14 §4.4). Returns the assigned groups too.
+ */
+export declare function startVariables(instanceId: string, declared: CompiledVariables, experiments: CompiledExperiments, given: Record<string, unknown>): {
+    variables: Record<string, unknown>;
+    experiments: Record<string, string>;
+};
+/**
+ * The current value of each variable as a run reads it (14 §4.4 "sequence 版本变化"): a stored value
+ * the declaration no longer allows (a removed variable or option) falls back to the default.
+ * `onStale` hears each fallback. Stored values are not changed.
+ */
+export declare function readVariables(declared: CompiledVariables, stored: Record<string, unknown>, onStale?: (name: string, value: unknown) => void): Record<string, unknown>;
+/** Bytes of `variables` serialized: what {@link LIMITS.variablesBytes} bounds. */
+export declare function variablesSize(variables: Record<string, unknown>): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/sequence/index.js

@@ -0,0 +1,231 @@
+/**
+ * Sequence-level declarations (14-sequence-instance §4.4–§4.5): the business root a sequence runs
+ * about (`index.ts`: `defineSequence({ subject })`) and its run variables and experiments
+ * (`variables.ts`). Compiled into `SequenceBuild.subject` / `.variables` / `.experiments`; the
+ * platform validates writes and assigns experiments with the helpers here.
+ */
+import { POLICY_IDS } from '../slot/company-metadata.js';
+export { defineSequence, defineVariables, json, } from './define.js';
+/**
+ * Run variable names the platform reserves (14 §4.4). It reads `voice` when it opens a session;
+ * `responsePolicy` and `slotFillingPolicy` are reserved and not read yet. A sequence may leave them
+ * out (the platform default) or declare them as enums whose values the platform knows.
+ */
+export const SYSTEM_VARIABLES = ['responsePolicy', 'slotFillingPolicy', 'voice'];
+export function isSystemVariable(name) {
+    return SYSTEM_VARIABLES.includes(name);
+}
+const VARIABLE_NAME = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+/** The values a system variable may take: the policy catalog. */
+function systemVariableValues(name) {
+    switch (name) {
+        case 'responsePolicy':
+            return POLICY_IDS.response;
+        case 'slotFillingPolicy':
+            return POLICY_IDS.slotFilling;
+        case 'voice':
+            return POLICY_IDS.voice;
+    }
+}
+/** Normalize and check a sequence's `variables.ts` (14 §4.4). */
+export function compileVariables(declared, experiments) {
+    const issues = [];
+    const variables = {};
+    const decls = declared && typeof declared === 'object' && !Array.isArray(declared) ? declared : {};
+    if (declared !== undefined && decls !== declared)
+        issues.push('variables must be an object of declarations');
+    for (const [name, raw] of Object.entries(decls)) {
+        if (!VARIABLE_NAME.test(name)) {
+            issues.push(`variable '${name}': a name is a letter then letters, digits or _ (at most 64)`);
+            continue;
+        }
+        const compiled = compileVariable(name, raw, issues);
+        if (!compiled)
+            continue;
+        if (isSystemVariable(name)) {
+            const allowed = systemVariableValues(name);
+            if (compiled.type !== 'enum') {
+                issues.push(`variable '${name}' is the platform's: declare it with options (one of ${allowed.join(', ') || 'none'})`);
+                continue;
+            }
+            const unknown = compiled.options.filter((value) => typeof value !== 'string' || !allowed.includes(value));
+            if (unknown.length > 0) {
+                issues.push(`variable '${name}': ${unknown.join(', ')} not one of ${allowed.join(', ') || '(none)'}`);
+                continue;
+            }
+        }
+        variables[name] = compiled;
+    }
+    const compiledExperiments = {};
+    const exps = experiments && typeof experiments === 'object' && !Array.isArray(experiments)
+        ? experiments
+        : {};
+    for (const [name, raw] of Object.entries(exps)) {
+        const exp = raw;
+        const variable = exp && typeof exp.variable === 'string' ? variables[exp.variable] : undefined;
+        if (!exp || typeof exp.variable !== 'string' || !variable) {
+            issues.push(`experiment '${name}': variable must name a declared variable`);
+            continue;
+        }
+        if (variable.type !== 'enum') {
+            issues.push(`experiment '${name}': only an enum variable (one declared with options) can be split`);
+            continue;
+        }
+        const split = exp.split && typeof exp.split === 'object' ? exp.split : {};
+        const entries = Object.entries(split);
+        const options = variable.options.map(String);
+        const bad = entries.filter(([value, share]) => !options.includes(value) || typeof share !== 'number' || share < 0);
+        if (entries.length === 0 || bad.length > 0 || entries.every(([, share]) => share === 0)) {
+            issues.push(`experiment '${name}': split gives non-negative shares to values of '${exp.variable}' (${options.join(', ')})`);
+            continue;
+        }
+        if (Object.values(compiledExperiments).some((other) => other.variable === exp.variable)) {
+            issues.push(`experiment '${name}': '${exp.variable}' is already split by another experiment`);
+            continue;
+        }
+        compiledExperiments[name] = { variable: exp.variable, split: Object.fromEntries(entries) };
+    }
+    return { variables, experiments: compiledExperiments, issues };
+}
+function compileVariable(name, raw, issues) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        issues.push(`variable '${name}': a declaration is an object ({ options } or { type })`);
+        return null;
+    }
+    const decl = raw;
+    const hasDefault = Object.hasOwn(decl, 'default') && decl.default !== undefined;
+    if (Array.isArray(decl.options)) {
+        const options = decl.options;
+        if (options.length === 0 || options.some((value) => !['string', 'number', 'boolean'].includes(typeof value))) {
+            issues.push(`variable '${name}': options are a non-empty list of strings, numbers or booleans`);
+            return null;
+        }
+        if (hasDefault && decl.default !== null && !options.includes(decl.default)) {
+            issues.push(`variable '${name}': default ${String(decl.default)} is not one of its options`);
+            return null;
+        }
+        return {
+            type: 'enum',
+            options: options,
+            default: hasDefault ? decl.default : null,
+        };
+    }
+    const type = decl.type;
+    if (type === 'string' || type === 'number' || type === 'boolean') {
+        if (hasDefault && decl.default !== null && typeof decl.default !== type) {
+            issues.push(`variable '${name}': default must be a ${type}`);
+            return null;
+        }
+        return { type, default: hasDefault ? decl.default : null };
+    }
+    if (type && typeof type === 'object' && type.kind === 'json') {
+        if (hasDefault && !serializes(decl.default)) {
+            issues.push(`variable '${name}': default must serialize as JSON`);
+            return null;
+        }
+        return { type: 'json', default: hasDefault ? decl.default : null };
+    }
+    issues.push(`variable '${name}': declare options, or type 'string' | 'number' | 'boolean' | json()`);
+    return null;
+}
+function serializes(value) {
+    try {
+        return JSON.stringify(value) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/** Why `value` cannot be stored in the variable; null when it can. `null` always can (unset). */
+export function variableValueIssue(name, variable, value) {
+    if (!variable)
+        return `unknown variable '${name}' (declare it in variables.ts)`;
+    if (value === null)
+        return null;
+    switch (variable.type) {
+        case 'enum':
+            return variable.options.includes(value) ? null : `'${name}' must be one of ${variable.options.join(', ')}`;
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return typeof value === variable.type ? null : `'${name}' must be a ${variable.type}`;
+        case 'json':
+            return value !== undefined && serializes(value) ? null : `'${name}' must serialize as JSON`;
+    }
+}
+/** Issues of a whole write of variables (unknown names, wrong types); empty when it may be stored. */
+export function variablesWriteIssues(variables, values) {
+    return Object.entries(values)
+        .map(([name, value]) => variableValueIssue(name, variables[name], value))
+        .filter((issue) => issue !== null);
+}
+/**
+ * The variables a new run starts with: every declared default, then the values given, then each
+ * experiment whose variable was not given assigns a value by `hash(instanceId + experiment)`, so the
+ * same instance always lands in the same group (14 §4.4). Returns the assigned groups too.
+ */
+export function startVariables(instanceId, declared, experiments, given) {
+    const variables = {};
+    for (const [name, variable] of Object.entries(declared)) {
+        if (variable.default !== null && variable.default !== undefined)
+            variables[name] = variable.default;
+    }
+    Object.assign(variables, given);
+    const assigned = {};
+    for (const [name, experiment] of Object.entries(experiments)) {
+        if (Object.hasOwn(given, experiment.variable))
+            continue;
+        const value = pickByShare(`${instanceId}:${name}`, experiment.split);
+        const variable = declared[experiment.variable];
+        // A split value is a string key; the variable's option may be a number or boolean.
+        const option = variable?.type === 'enum' ? (variable.options.find((candidate) => String(candidate) === value) ?? value) : value;
+        variables[experiment.variable] = option;
+        assigned[name] = value;
+    }
+    return { variables, experiments: assigned };
+}
+/**
+ * The current value of each variable as a run reads it (14 §4.4 "sequence 版本变化"): a stored value
+ * the declaration no longer allows (a removed variable or option) falls back to the default.
+ * `onStale` hears each fallback. Stored values are not changed.
+ */
+export function readVariables(declared, stored, onStale) {
+    const out = {};
+    for (const [name, variable] of Object.entries(declared)) {
+        const has = Object.hasOwn(stored, name);
+        const value = has ? stored[name] : variable.default;
+        if (has && variableValueIssue(name, variable, value) !== null) {
+            onStale?.(name, value);
+            out[name] = variable.default ?? null;
+            continue;
+        }
+        out[name] = value ?? null;
+    }
+    for (const [name, value] of Object.entries(stored)) {
+        if (!Object.hasOwn(declared, name))
+            onStale?.(name, value);
+    }
+    return out;
+}
+/** Deterministic weighted pick: FNV-1a of `key` into the cumulative shares. */
+function pickByShare(key, split) {
+    const entries = Object.entries(split).filter(([, share]) => share > 0);
+    const total = entries.reduce((sum, [, share]) => sum + share, 0);
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < key.length; i += 1) {
+        hash ^= key.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    let point = (hash / 0x100000000) * total;
+    for (const [value, share] of entries) {
+        if (point < share)
+            return value;
+        point -= share;
+    }
+    return entries[entries.length - 1][0];
+}
+/** Bytes of `variables` serialized: what {@link LIMITS.variablesBytes} bounds. */
+export function variablesSize(variables) {
+    return new TextEncoder().encode(JSON.stringify(variables)).length;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,40 @@
+import type { FieldState } from '../context/types.js';
+/**
+ * Where a slot cell is stored, as the generated `Rows` type marks it: a cell's
+ * `(table, row id, field)` and a row's `(table, id)`.
+ */
+/** Where a cell is stored: `(table, row id, field)`. */
+export type CellRef<T extends string = string, F extends string = string> = {
+    table: T;
+    rowId: string;
+    field: F;
+};
+/** A row's binding: `(table, row id)`. */
+export type RowRef<T extends string = string> = {
+    table: T;
+    id: string;
+};
+declare const cellMode: unique symbol;
+declare const cellKind: unique symbol;
+/**
+ * The binding part of a cell type: `ref`, and phantom marks codegen adds to every field of
+ * `Rows`. Mode `'rw'`: a page may open it with `field(...)`; `'ro'`: the row id
+ * or the parent, which no page opens (19-page-writable-cells). Kind `'ref'`: a ref field (another row's id), which a region never lists.
+ */
+export type CellBinding<T extends string = string, F extends string = string, M extends 'rw' | 'ro' = 'rw' | 'ro', K extends 'value' | 'ref' = 'value' | 'ref'> = {
+    ref: CellRef<T, F>;
+    readonly [cellMode]?: M;
+    readonly [cellKind]?: K;
+};
+/** A slot cell as a view receives it: the value and state, and where it is stored. */
+export type Cell<T extends string = string, F extends string = string, V = unknown, M extends 'rw' | 'ro' = 'rw' | 'ro'> = {
+    value: V;
+    state: FieldState;
+} & CellBinding<T, F, M>;
+/** A bound row as a view receives it. */
+export type BoundRow = {
+    id: string;
+    $ref: RowRef<string>;
+};
+export {};
+//# sourceMappingURL=binding.d.ts.map

package/dist/core/slot/binding.js

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

package/dist/core/slot/company-metadata.d.ts

@@ -0,0 +1,102 @@
+import type { CompanyFieldDef, CompanySchema, SessionSchema, TableRef } from './schema.js';
+import type { ValidationIssue, ValidationResult } from './types.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 declare const CONTACT_TABLE = "contact";
+/** The conversation's table: its fields are the company's `schema/session.ts`; no company table has this name. */
+export declare const SESSION_TABLE = "session";
+export declare const CONTACT_OPT_OUT_FIELDS: readonly ['opted_out', 'call_opted_out', 'sms_opted_out', 'email_opted_out'];
+/** Platform limits (14-sequence-instance §16.1). */
+export declare const LIMITS: {
+    /** Longest parent chain: a table's parent's parent … at most this many hops to a table without one. */
+    readonly parentDepth: 5;
+    /** An instance's `variables`, serialized, bytes. */
+    readonly variablesBytes: number;
+    /** Company tables per company and environment (18-record-search-index §4.7). */
+    readonly tables: 100;
+    /** Fields per table, platform fields included. */
+    readonly fieldsPerTable: 300;
+    /** `options` of one `select` / `multi_select` field (a longer list is a table and a lookupRef). */
+    readonly options: 200;
+    /** Characters of one option: a short code, not a sentence (its meaning goes in `extraction`). */
+    readonly 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).
+     */
+    readonly stringBytes: 2500;
+    /** A `text` value, UTF-8 bytes: the storage's bound, not a business one (34 §2). */
+    readonly textBytes: number;
+    /** One row's stored data, serialized, UTF-8 bytes. */
+    readonly rowDataBytes: number;
+};
+/**
+ * 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 declare const POLICY_IDS: {
+    readonly response: readonly ['default'];
+    readonly slotFilling: readonly ['default'];
+    readonly voice: readonly ['default'];
+};
+export type ResponsePolicyId = (typeof POLICY_IDS.response)[number];
+export type SlotFillingPolicyId = (typeof POLICY_IDS.slotFilling)[number];
+export type VoiceProfileId = (typeof POLICY_IDS.voice)[number];
+/** Session fields with the platform's only: what a company without fields of its own declares. */
+export declare const PLATFORM_SESSION_SCHEMA: SessionSchema;
+/** Each table's platform fields, with the name its issue codes use (`missing-platform-<name>-field`). */
+export declare const PLATFORM_TABLE_FIELDS: Readonly<Record<string, {
+    name: string;
+    fields: Record<string, CompanyFieldDef>;
+}>>;
+/**
+ * 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 declare function isCustomTable(tableName: string): boolean;
+/** A table whose rows are `Record` rows: every company table, contact included. */
+export declare function isRecordTable(tableName: string): boolean;
+type FieldsOf = {
+    fields: Record<string, {
+        ref?: TableRef | null;
+    } | CompanyFieldDef>;
+};
+/** A table's parent: the field name and the table it points at; null when it has none. */
+export declare function parentOf(table: FieldsOf | undefined): {
+    field: string;
+    table: string;
+} | 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 declare function isParentField(table: FieldsOf | undefined, fieldName: string): boolean;
+/**
+ * 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 declare function sessionSchemaIssues(session: SessionSchema): ValidationIssue[];
+/**
+ * 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 declare function validateCompanySchema(company: CompanySchema, session?: SessionSchema): ValidationResult;
+/** The issue for a field that still names its `source` (19-page-writable-cells). */
+export declare function sourceRemovedIssue(path: string, prefix?: string): ValidationIssue;
+/** The issue for a field that still names `nullable`, which no write checked. */
+export declare function nullableRemovedIssue(path: string, prefix?: string): ValidationIssue;
+/** The issue for a field that still names `identifier`, which nothing used. */
+export declare function identifierRemovedIssue(path: string, prefix?: string): ValidationIssue;
+/**
+ * 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 declare function optionIssues(path: string, field: Record<string, unknown>, prefix?: string): ValidationIssue[];
+/** The issue for a table that writes the row id, which is the platform's. */
+export declare function idIsPlatformIssue(path: string): ValidationIssue;
+/** The company table a sequence names as its business root, checked (14 §4.5). */
+export declare function subjectTableIssues(company: CompanySchema, subject: unknown): ValidationIssue[];
+//# sourceMappingURL=company-metadata.d.ts.map