@superpanel-sdk/runtime 0.2.2 → 0.5.0

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

@@ -1,83 +1,37 @@
-import { ROW_ID_FIELD } from './schema.js';
-import { createPlatformSessionTable, PLATFORM_SESSION_FIELDS } from './platform-session-fields.js';
-import { isReservedTableName, isRowIdField } from './row.js';
-import { resolveFuncName } from '../functions/func-ref.js';
-import { buildDependencyGraph } from './deps.js';
+import { idFieldCore, ROW_ID_FIELD } from './schema.js';
+import { isReservedTableName } from './row.js';
+import { compileCompanyMetadata, PLATFORM_SESSION_SCHEMA, SESSION_TABLE } from './company-metadata.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,
-        };
-    }
+function toRuntimeField(field) {
     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,
+        options: field.options ?? null,
         ref: 'ref' in field && field.ref ? field.ref : null,
+        ...('unique' in field && field.unique ? { unique: true } : {}),
         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);
+export function companyFieldToRuntime(field) {
+    return toRuntimeField(field);
 }
-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,
-        });
-    }
+/** Every row's id, the platform's: the first field of every table and of the session. */
+const ROW_ID = { ...idFieldCore, options: null, ref: null };
+/** The session table: one row per conversation, its row id and the company's session fields. */
+function sessionTable(session) {
+    const fields = { [ROW_ID_FIELD]: { ...ROW_ID } };
+    for (const [fieldName, field] of Object.entries(session.fields))
+        fields[fieldName] = toRuntimeField(field);
+    return { label: 'Session', description: 'This conversation', fields };
 }
 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]) {
+            if (!Object.hasOwn(company, targetTable)) {
                 issues.push({
                     code: 'unknown-ref-table',
                     message: `ref table not in company schema: ${targetTable}`,
@@ -88,169 +42,37 @@ function validateCompanyRefs(company, issues) {
     }
 }
 /**
- * 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 function compileSlotSchema(company, sequenceSlots, options = {}) {
+export function compileSlotSchema(company, options = {}) {
     const issues = [];
-    const tables = {
-        session: createPlatformSessionTable(),
-    };
+    const session = options.session ?? PLATFORM_SESSION_SCHEMA;
+    const companyCheck = compileCompanyMetadata(company, session);
+    if (!companyCheck.validation.ok)
+        issues.push(...companyCheck.validation.issues);
+    const tables = {};
     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,
-                });
-            }
+        // Reserved table names are the company schema's to report (compileCompanyMetadata).
+        if (tableName === SESSION_TABLE || isReservedTableName(tableName))
             continue;
-        }
-        const fields = {};
+        // The row id is the platform's: a schema that writes one is refused (compileCompanyMetadata).
+        const fields = { [ROW_ID_FIELD]: { ...ROW_ID } };
         for (const [fieldName, field] of Object.entries(companyTable.fields)) {
-            fields[fieldName] = toRuntimeField(field, options.functions);
+            if (fieldName !== ROW_ID_FIELD)
+                fields[fieldName] = toRuntimeField(field);
         }
-        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 (!tableView)
-            continue;
-        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);
-            }
-            Object.assign(fields, PLATFORM_SESSION_FIELDS);
-            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);
-        }
-    }
+    // Every sequence has the session row with all of the company's session fields.
+    tables.session = sessionTable(session);
     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,
-    };
+    const schema = { ...tables };
     return {
         schema,
         validation: issues.length === 0 ? { ok: true } : { ok: false, issues },
@@ -280,8 +102,23 @@ export function validateFieldRefs(schema, refs) {
     }
     return issues.length === 0 ? { ok: true } : { ok: false, issues };
 }
+/** The ways back to `tableName`: every ref of this schema that points at it and has a `relatedName`. */
+export function relationsOf(schema, tableName) {
+    const out = [];
+    for (const [childName, child] of compiledTableEntries(schema)) {
+        for (const [field, def] of Object.entries(child.fields)) {
+            if (def.ref?.table === tableName && def.ref.relatedName !== undefined)
+                out.push({ name: def.ref.relatedName, table: childName, field });
+        }
+    }
+    return out;
+}
+/** A table's own field by name; undefined for any other key, a name every object has (`toString`) included. */
+export function getTableField(table, fieldName) {
+    return Object.hasOwn(table.fields, fieldName) ? table.fields[fieldName] : undefined;
+}
 export function getCompiledTable(schema, tableName) {
-    if (isReservedTableName(tableName))
+    if (isReservedTableName(tableName) || !Object.hasOwn(schema, tableName))
         return undefined;
     const value = schema[tableName];
     if (!value || typeof value !== 'object' || Array.isArray(value) || !('fields' in value)) {
@@ -298,38 +135,4 @@ export function compiledTableEntries(schema) {
     }
     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

package/dist/core/slot/contact-timezone.d.ts

@@ -0,0 +1,110 @@
+/**
+ * A contact's timezone when its `timezone` field is empty (25 §2.2): from its postal code, then its
+ * state, then its phone's area code. Read only: nothing is written back to `timezone`, which stays what
+ * the contact said (its extraction forbids inferring it from a phone number).
+ *
+ * The tables cover the US (with its territories) and Canada, the platform's numbers. A state in two
+ * zones gets its most populous one; the postal-code and area-code exceptions below fix the parts that
+ * differ (the Florida panhandle, El Paso, east Tennessee, north Idaho…).
+ */
+/** US states, territories and DC, and Canadian provinces and territories: their main IANA zone. */
+export declare const STATE_TIMEZONES: {
+    readonly AL: 'America/Chicago';
+    readonly AK: 'America/Anchorage';
+    readonly AZ: 'America/Phoenix';
+    readonly AR: 'America/Chicago';
+    readonly CA: 'America/Los_Angeles';
+    readonly CO: 'America/Denver';
+    readonly CT: 'America/New_York';
+    readonly DE: 'America/New_York';
+    readonly DC: 'America/New_York';
+    readonly FL: 'America/New_York';
+    readonly GA: 'America/New_York';
+    readonly HI: 'Pacific/Honolulu';
+    readonly ID: 'America/Boise';
+    readonly IL: 'America/Chicago';
+    readonly IN: 'America/Indiana/Indianapolis';
+    readonly IA: 'America/Chicago';
+    readonly KS: 'America/Chicago';
+    readonly KY: 'America/New_York';
+    readonly LA: 'America/Chicago';
+    readonly ME: 'America/New_York';
+    readonly MD: 'America/New_York';
+    readonly MA: 'America/New_York';
+    readonly MI: 'America/Detroit';
+    readonly MN: 'America/Chicago';
+    readonly MS: 'America/Chicago';
+    readonly MO: 'America/Chicago';
+    readonly MT: 'America/Denver';
+    readonly NE: 'America/Chicago';
+    readonly NV: 'America/Los_Angeles';
+    readonly NH: 'America/New_York';
+    readonly NJ: 'America/New_York';
+    readonly NM: 'America/Denver';
+    readonly NY: 'America/New_York';
+    readonly NC: 'America/New_York';
+    readonly ND: 'America/Chicago';
+    readonly OH: 'America/New_York';
+    readonly OK: 'America/Chicago';
+    readonly OR: 'America/Los_Angeles';
+    readonly PA: 'America/New_York';
+    readonly RI: 'America/New_York';
+    readonly SC: 'America/New_York';
+    readonly SD: 'America/Chicago';
+    readonly TN: 'America/Chicago';
+    readonly TX: 'America/Chicago';
+    readonly UT: 'America/Denver';
+    readonly VT: 'America/New_York';
+    readonly VA: 'America/New_York';
+    readonly WA: 'America/Los_Angeles';
+    readonly WV: 'America/New_York';
+    readonly WI: 'America/Chicago';
+    readonly WY: 'America/Denver';
+    readonly PR: 'America/Puerto_Rico';
+    readonly VI: 'America/St_Thomas';
+    readonly GU: 'Pacific/Guam';
+    readonly AS: 'Pacific/Pago_Pago';
+    readonly MP: 'Pacific/Saipan';
+    readonly AB: 'America/Edmonton';
+    readonly BC: 'America/Vancouver';
+    readonly MB: 'America/Winnipeg';
+    readonly NB: 'America/Moncton';
+    readonly NL: 'America/St_Johns';
+    readonly NS: 'America/Halifax';
+    readonly NT: 'America/Yellowknife';
+    readonly NU: 'America/Iqaluit';
+    readonly ON: 'America/Toronto';
+    readonly PE: 'America/Halifax';
+    readonly QC: 'America/Toronto';
+    readonly SK: 'America/Regina';
+    readonly YT: 'America/Whitehorse';
+};
+/** A two-letter US state, territory, DC or Canadian province code. */
+export type StateCode = keyof typeof STATE_TIMEZONES;
+/** The codes `state` takes (the platform field's allowed values). */
+export declare const STATE_CODES: StateCode[];
+/** `value` when it names a zone this runtime knows, else null. */
+export declare function knownTimezone(value: unknown): string | null;
+/** A two-letter state or province code (any case), else null. */
+export declare function stateCode(value: unknown): StateCode | null;
+/** The zone of a US ZIP (5 digits or ZIP+4) or a Canadian postal code; null when not one. */
+export declare function postalTimezone(value: unknown): string | null;
+/** The zone of a North American number's area code (E.164 `+1NXX…`); null for any other. */
+export declare function areaCodeTimezone(phone: unknown): string | null;
+export type TimezoneSource = 'timezone' | 'postal_code' | 'state' | 'phone' | 'default';
+/**
+ * The contact's zone and where it came from: its own `timezone`, else its postal code, its state, its
+ * phone's area code, and last `fallback`. A contact in another country (`country` set, not the US or
+ * Canada) skips the postal code and state: a 5-digit code abroad is not a ZIP.
+ */
+export declare function contactTimezone(fields: {
+    timezone?: unknown;
+    postal_code?: unknown;
+    state?: unknown;
+    country?: unknown;
+    phone?: unknown;
+}, fallback: string): {
+    timezone: string;
+    source: TimezoneSource;
+};
+//# sourceMappingURL=contact-timezone.d.ts.map

package/dist/core/slot/contact-timezone.js

@@ -0,0 +1,186 @@
+/**
+ * A contact's timezone when its `timezone` field is empty (25 §2.2): from its postal code, then its
+ * state, then its phone's area code. Read only: nothing is written back to `timezone`, which stays what
+ * the contact said (its extraction forbids inferring it from a phone number).
+ *
+ * The tables cover the US (with its territories) and Canada, the platform's numbers. A state in two
+ * zones gets its most populous one; the postal-code and area-code exceptions below fix the parts that
+ * differ (the Florida panhandle, El Paso, east Tennessee, north Idaho…).
+ */
+/** US states, territories and DC, and Canadian provinces and territories: their main IANA zone. */
+export const STATE_TIMEZONES = {
+    AL: 'America/Chicago', AK: 'America/Anchorage', AZ: 'America/Phoenix', AR: 'America/Chicago',
+    CA: 'America/Los_Angeles', CO: 'America/Denver', CT: 'America/New_York', DE: 'America/New_York',
+    DC: 'America/New_York', FL: 'America/New_York', GA: 'America/New_York', HI: 'Pacific/Honolulu',
+    ID: 'America/Boise', IL: 'America/Chicago', IN: 'America/Indiana/Indianapolis', IA: 'America/Chicago',
+    KS: 'America/Chicago', KY: 'America/New_York', LA: 'America/Chicago', ME: 'America/New_York',
+    MD: 'America/New_York', MA: 'America/New_York', MI: 'America/Detroit', MN: 'America/Chicago',
+    MS: 'America/Chicago', MO: 'America/Chicago', MT: 'America/Denver', NE: 'America/Chicago',
+    NV: 'America/Los_Angeles', NH: 'America/New_York', NJ: 'America/New_York', NM: 'America/Denver',
+    NY: 'America/New_York', NC: 'America/New_York', ND: 'America/Chicago', OH: 'America/New_York',
+    OK: 'America/Chicago', OR: 'America/Los_Angeles', PA: 'America/New_York', RI: 'America/New_York',
+    SC: 'America/New_York', SD: 'America/Chicago', TN: 'America/Chicago', TX: 'America/Chicago',
+    UT: 'America/Denver', VT: 'America/New_York', VA: 'America/New_York', WA: 'America/Los_Angeles',
+    WV: 'America/New_York', WI: 'America/Chicago', WY: 'America/Denver',
+    PR: 'America/Puerto_Rico', VI: 'America/St_Thomas', GU: 'Pacific/Guam', AS: 'Pacific/Pago_Pago', MP: 'Pacific/Saipan',
+    AB: 'America/Edmonton', BC: 'America/Vancouver', MB: 'America/Winnipeg', NB: 'America/Moncton',
+    NL: 'America/St_Johns', NS: 'America/Halifax', NT: 'America/Yellowknife', NU: 'America/Iqaluit',
+    ON: 'America/Toronto', PE: 'America/Halifax', QC: 'America/Toronto', SK: 'America/Regina', YT: 'America/Whitehorse',
+};
+/** The codes `state` takes (the platform field's allowed values). */
+export const STATE_CODES = Object.keys(STATE_TIMEZONES);
+/** US ZIP code prefixes (first three digits), as inclusive ranges, by state (USPS). */
+const ZIP3_RANGES = [
+    [5, 5, 'NY'], [6, 7, 'PR'], [8, 8, 'VI'], [9, 9, 'PR'], [10, 27, 'MA'], [28, 29, 'RI'], [30, 38, 'NH'],
+    [39, 49, 'ME'], [50, 59, 'VT'], [60, 69, 'CT'], [70, 89, 'NJ'], [100, 149, 'NY'], [150, 196, 'PA'],
+    [197, 199, 'DE'], [200, 205, 'DC'], [206, 219, 'MD'], [220, 246, 'VA'], [247, 268, 'WV'], [270, 289, 'NC'],
+    [290, 299, 'SC'], [300, 319, 'GA'], [320, 349, 'FL'], [350, 369, 'AL'], [370, 385, 'TN'], [386, 397, 'MS'],
+    [398, 399, 'GA'], [400, 427, 'KY'], [430, 459, 'OH'], [460, 479, 'IN'], [480, 499, 'MI'], [500, 528, 'IA'],
+    [530, 549, 'WI'], [550, 567, 'MN'], [569, 569, 'DC'], [570, 577, 'SD'], [580, 588, 'ND'], [590, 599, 'MT'],
+    [600, 629, 'IL'], [630, 658, 'MO'], [660, 679, 'KS'], [680, 693, 'NE'], [700, 714, 'LA'], [716, 729, 'AR'],
+    [730, 749, 'OK'], [750, 799, 'TX'], [800, 816, 'CO'], [820, 831, 'WY'], [832, 838, 'ID'], [840, 847, 'UT'],
+    [850, 865, 'AZ'], [870, 884, 'NM'], [885, 885, 'TX'], [889, 898, 'NV'], [900, 961, 'CA'], [967, 968, 'HI'],
+    [969, 969, 'GU'], [970, 979, 'OR'], [980, 994, 'WA'], [995, 999, 'AK'],
+];
+/** ZIP prefixes in another zone than their state's main one. */
+const ZIP3_TIMEZONES = {
+    324: 'America/Chicago', 325: 'America/Chicago', // Florida panhandle west of the Apalachicola
+    373: 'America/New_York', 374: 'America/New_York', 376: 'America/New_York', // east Tennessee
+    377: 'America/New_York', 378: 'America/New_York', 379: 'America/New_York',
+    420: 'America/Chicago', 421: 'America/Chicago', 422: 'America/Chicago', 423: 'America/Chicago', 424: 'America/Chicago', // west Kentucky
+    463: 'America/Chicago', 464: 'America/Chicago', 476: 'America/Chicago', 477: 'America/Chicago', // northwest and southwest Indiana
+    577: 'America/Denver', // west South Dakota (Rapid City)
+    693: 'America/Denver', // Nebraska panhandle
+    798: 'America/Denver', 799: 'America/Denver', 885: 'America/Denver', // El Paso
+    835: 'America/Los_Angeles', 838: 'America/Los_Angeles', // north Idaho
+    979: 'America/Boise', // east Oregon (Ontario)
+};
+/** Canadian postal codes: the first letter's province. */
+const CANADA_POSTAL = {
+    A: 'NL', B: 'NS', C: 'PE', E: 'NB', G: 'QC', H: 'QC', J: 'QC', K: 'ON', L: 'ON', M: 'ON', N: 'ON', P: 'ON',
+    R: 'MB', S: 'SK', T: 'AB', V: 'BC', X: 'NT', Y: 'YT',
+};
+/** North American area codes by state or province (geographic ones; toll-free and non-geographic are left out). */
+const AREA_CODES = byCode({
+    AL: '205 251 256 334 659 938', AK: '907', AZ: '480 520 602 623 928', AR: '327 479 501 870',
+    CA: '209 213 279 310 323 341 350 369 408 415 424 442 510 530 559 562 619 626 628 650 657 661 669 707 714 747 760 805 818 820 831 840 858 909 916 925 949 951',
+    CO: '303 719 720 970 983', CT: '203 475 860 959', DE: '302', DC: '202 771',
+    FL: '239 305 321 324 352 386 407 448 561 645 656 689 727 728 754 772 786 813 850 863 904 941 954',
+    GA: '229 404 470 478 678 706 762 770 912 943', HI: '808', ID: '208 986',
+    IL: '217 224 309 312 331 447 464 618 630 708 730 773 779 815 847 861 872', IN: '219 260 317 463 574 765 812 930',
+    IA: '319 515 563 641 712', KS: '316 620 785 913', KY: '270 364 502 606 859', LA: '225 318 337 504 985', ME: '207',
+    MD: '227 240 301 410 443 667', MA: '339 351 413 508 617 774 781 857 978',
+    MI: '231 248 269 313 517 586 616 679 734 810 906 947 989', MN: '218 320 507 612 651 763 924 952',
+    MS: '228 471 601 662 769', MO: '235 314 417 557 573 636 660 816 975', MT: '406', NE: '308 402 531',
+    NV: '702 725 775', NH: '603', NJ: '201 551 609 640 732 848 856 862 908 973', NM: '505 575',
+    NY: '212 315 329 332 347 363 516 518 585 607 624 631 646 680 716 718 838 845 914 917 929 934',
+    NC: '252 336 472 704 743 828 910 919 980 984', ND: '701',
+    OH: '216 220 234 283 326 330 380 419 436 440 513 567 614 740 937', OK: '405 539 572 580 918', OR: '458 503 541 971',
+    PA: '215 223 267 272 412 445 484 570 582 610 717 724 814 835 878', RI: '401', SC: '803 821 839 843 854 864', SD: '605',
+    TN: '423 615 629 731 865 901 931',
+    TX: '210 214 254 281 325 346 361 409 430 432 469 512 682 713 726 737 806 817 830 832 903 915 936 940 945 956 972 979',
+    UT: '385 435 801', VT: '802', VA: '276 434 540 571 686 703 757 804 826 948', WA: '206 253 360 425 509 564',
+    WV: '304 681', WI: '262 274 353 414 534 608 715 920', WY: '307',
+    PR: '787 939', VI: '340', GU: '671', AS: '684', MP: '670',
+    AB: '368 403 587 780 825', BC: '236 250 257 604 672 778', MB: '204 431 584', NB: '428 506', NL: '709 879', NS: '782 902',
+    ON: '226 249 289 343 365 382 387 416 437 519 548 613 647 683 705 742 753 807 905 942',
+    QC: '263 354 367 418 438 450 468 514 579 581 819 873', SK: '306 474 639', NT: '867',
+});
+/**
+ * Area codes in another zone than their state's main one. An area code that spans two zones keeps
+ * the eastern one: hours that end in the evening (Florida's 20:00) then still hold on the western
+ * side, an hour earlier there. So 850 / 448 (Tallahassee is Eastern, Pensacola Central) and 270 / 364
+ * (Elizabethtown is Eastern, Bowling Green Central) stay with their state's Eastern zone.
+ */
+const AREA_CODE_TIMEZONES = {
+    '915': 'America/Denver', // El Paso
+    '423': 'America/New_York', '865': 'America/New_York', // east Tennessee
+    '219': 'America/Chicago', // northwest Indiana
+};
+function byCode(lists) {
+    const out = {};
+    for (const [state, codes] of Object.entries(lists))
+        for (const code of codes.split(' '))
+            out[code] = state;
+    return out;
+}
+/** `value` when it names a zone this runtime knows, else null. */
+export function knownTimezone(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: value.trim() }).format();
+        return value.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** A two-letter state or province code (any case), else null. */
+export function stateCode(value) {
+    if (typeof value !== 'string')
+        return null;
+    const code = value.trim().toUpperCase();
+    return Object.hasOwn(STATE_TIMEZONES, code) ? code : null;
+}
+/** The zone of a US ZIP (5 digits or ZIP+4) or a Canadian postal code; null when not one. */
+export function postalTimezone(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim().toUpperCase();
+    const zip = /^(\d{5})(?:-?\d{4})?$/.exec(text);
+    if (zip) {
+        const prefix = Number(zip[1].slice(0, 3));
+        if (ZIP3_TIMEZONES[prefix])
+            return ZIP3_TIMEZONES[prefix];
+        const range = ZIP3_RANGES.find(([lo, hi]) => prefix >= lo && prefix <= hi);
+        return range ? STATE_TIMEZONES[range[2]] : null;
+    }
+    if (/^[A-Z]\d[A-Z] ?\d[A-Z]\d$/.test(text)) {
+        const province = CANADA_POSTAL[text[0]];
+        return province ? STATE_TIMEZONES[province] : null;
+    }
+    return null;
+}
+/** The zone of a North American number's area code (E.164 `+1NXX…`); null for any other. */
+export function areaCodeTimezone(phone) {
+    if (typeof phone !== 'string')
+        return null;
+    const match = /^\+1(\d{3})\d{7}$/.exec(phone.replace(/;ext=.*$/, ''));
+    if (!match)
+        return null;
+    const code = match[1];
+    if (AREA_CODE_TIMEZONES[code])
+        return AREA_CODE_TIMEZONES[code];
+    const state = AREA_CODES[code];
+    return state ? STATE_TIMEZONES[state] : null;
+}
+/** A country outside the US (and its territories) and Canada, whose postal codes and states the tables do not cover. */
+function foreignCountry(country) {
+    if (typeof country !== 'string' || country.trim() === '')
+        return false;
+    return !/^(US|USA|UNITED STATES|CA|CAN|CANADA|PR|GU|VI|AS|MP)$/.test(country.trim().toUpperCase());
+}
+/**
+ * The contact's zone and where it came from: its own `timezone`, else its postal code, its state, its
+ * phone's area code, and last `fallback`. A contact in another country (`country` set, not the US or
+ * Canada) skips the postal code and state: a 5-digit code abroad is not a ZIP.
+ */
+export function contactTimezone(fields, fallback) {
+    const own = knownTimezone(fields.timezone);
+    if (own)
+        return { timezone: own, source: 'timezone' };
+    if (!foreignCountry(fields.country)) {
+        const postal = postalTimezone(fields.postal_code);
+        if (postal)
+            return { timezone: postal, source: 'postal_code' };
+        const state = stateCode(fields.state);
+        if (state)
+            return { timezone: STATE_TIMEZONES[state], source: 'state' };
+    }
+    const area = areaCodeTimezone(fields.phone);
+    if (area)
+        return { timezone: area, source: 'phone' };
+    return { timezone: fallback, source: 'default' };
+}
+//# sourceMappingURL=contact-timezone.js.map