@salsita-ai/sdk 0.50.0-develop.ca72986c39 → 0.50.0-develop.d0eaeed131

package/dist/application-spec/generate-application/code/templates/spec-code/spec-code.d.ts

@@ -0,0 +1,18 @@
+import type { ApplicationTypeImportRegistrar } from '../../common/index.js';
+import { type SpecCodeDomain } from './collect-spec-code.js';
+/** The two domains of a parsed spec whose YAML code the generated module holds. */
+export interface SpecCodeSpec {
+    readonly configurator: SpecCodeDomain;
+    readonly admin: SpecCodeDomain;
+}
+/**
+ * Generates `.phoenix/spec-code.ts`: every piece of code written in YAML (`$eval` in value
+ * expressions, component props and filter criteria) as a closure, keyed by its spec code id, one
+ * map per domain. Each closure is typed by what it produces (the expression's type, the component
+ * prop's type, the filter criterion's type) and by the entity it runs on, so `phoenix check
+ * --types` checks the code as it checks generated domain code.
+ *
+ * Nothing imports the file yet; the runtime will look code up in it by id instead of compiling the
+ * text.
+ */
+export declare const generateApplicationSpecCodeFile: (spec: SpecCodeSpec, registerApplicationTypeImports?: ApplicationTypeImportRegistrar) => string;

package/dist/application-spec/generate-application/code/templates/spec-code/spec-code.js

@@ -0,0 +1,41 @@
+import{CodeImports as e,autoHeader as t,skipApplicationTypeImports as n}from"../../common/index.js";import{collectSpecCode as r}from"./collect-spec-code.js";let o="@salsita-ai/sdk/domain",s=`/**
+ * The type at one key of TYPE, or the item type of an array for a numeric key, taken from every
+ * member of a union that has it. \`unknown\` when no member has it, so that a type the path cannot
+ * follow loses the check instead of rejecting valid code.
+ */
+type SpecCodeMember<TYPE, KEY> = TYPE extends readonly (infer ITEM)[]
+  ? KEY extends number
+    ? ITEM
+    : never
+  : TYPE extends object
+    ? KEY extends keyof TYPE
+      ? TYPE[KEY]
+      : never
+    : never
+type SpecCodeAt<TYPE, KEY> = [SpecCodeMember<TYPE, KEY>] extends [never] ? unknown : SpecCodeMember<TYPE, KEY>`,i=`/** The value a component filter criterion yields, as \`withGradualFilter\` takes it: arrays read-only. */
+type SpecCodeFilterCriterion<KEY extends keyof ComponentSystemFilterProps> =
+  | ([Required<ComponentSystemFilterProps>[KEY]] extends [ReadonlyArray<infer ITEM>]
+      ? readonly ITEM[]
+      : Required<ComponentSystemFilterProps>[KEY])
+  | undefined`,p=`/**
+ * Types one closure: \`self\` is the entity it runs on, and what it returns must fit TARGET. The
+ * result is inferred as a constant and then checked against TARGET, as the dependencies of
+ * \`memoEval\` are in generated domain code.
+ */
+const code =
+  <SELF, TARGET>() =>
+  <const RESULT extends TARGET>(closure: (self: SELF) => RESULT): ((self: SELF) => RESULT) =>
+    closure`,a=(e,t,n)=>{if(0===t.length)return"unknown";let r=t.map(t=>(t.length>0&&(n.usesAt=!0),t.reduce((e,t)=>`SpecCodeAt<${e}, ${"number"==typeof t?"number":JSON.stringify(t)}>`,e)));return 1===r.length?r[0]:r.map(e=>`(${e})`).join(" & ")},d=(e,t,n)=>0===e.length?"{}":`{
+${e.map(e=>{let r,s,i;return t.registerOwnerTypes([`$${e.owner}`]),r=`${t.typePrefix}$${e.owner}`,s=((e,t,n,r)=>{if("filter"===e.kind)return r.usesFilter=!0,r.imports.addTypeImport(o,"ComponentSystemFilterProps"),`SpecCodeFilterCriterion<'${e.criterion}'>`;if("component"===e.kind){let t=`${e.componentName}Component`;return r.imports.addTypeImport(o,"StateOfComponent"),r.imports.addTypeImport(o,t),a(`StateOfComponent<typeof ${t}>`,e.paths,r)}return n.registerOwnerTypes([`${t}Expressions`]),a(`${n.typePrefix}${t}Expressions['${e.name}']`,e.paths,r)})(e.target,e.owner,t,n),i=e.usesSelf?`self => (${e.code}
+)`:`() => (${e.code}
+)`,`    ${JSON.stringify(e.id)}: code<${r}, ${s}>()(${i}),`}).join("\n")}
+  }`;export const generateApplicationSpecCodeFile=(o,a=n)=>{let m=new e,c={imports:m,usesAt:!1,usesFilter:!1},l=r(o.configurator),y=r(o.admin),f=d(l,{typePrefix:"",registerOwnerTypes:e=>a(m,e)},c),u=d(y,{typePrefix:"Admin.",registerOwnerTypes:()=>a(m,["Admin"])},c),E=[...c.usesAt?[s]:[],...c.usesFilter?[i]:[],...l.length+y.length>0?[p]:[]];return`${t("spec-code.ts","Code written in YAML ($eval in expressions, component props and filters) as typed closures, keyed by spec code id.")}
+${m.toString()}
+
+${E.map(e=>`${e}
+
+`).join("")}export const specCode = {
+  configurator: ${f},
+  admin: ${u},
+}
+`};

package/dist/application-spec/generate-application/code/templates/spec-messages/index.d.ts

@@ -0,0 +1 @@
+export { generateApplicationSpecMessagesFile } from './spec-messages.js';

package/dist/application-spec/generate-application/code/templates/spec-messages/index.js

@@ -0,0 +1 @@
+export{generateApplicationSpecMessagesFile}from"./spec-messages.js";

package/dist/application-spec/generate-application/code/templates/spec-messages/spec-messages.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentEntry, Defaults, Expressions, Invariants } from '../../../../parse-application-files/index.js';
+/** The sections of one domain whose `$msg` texts generated domain code turns into `msg` calls. */
+export interface SpecMessagesDomain {
+    readonly expressions: Expressions;
+    readonly components: readonly ComponentEntry[];
+    readonly invariants: Invariants;
+    readonly defaults: Defaults;
+}
+/** The two domains of a parsed spec whose texts the generated messages file holds. */
+export interface SpecMessagesSpec {
+    readonly configurator: SpecMessagesDomain;
+    readonly admin: SpecMessagesDomain;
+}
+/**
+ * Generates `.phoenix/spec-messages.ts`: one `msg` call for each distinct `$msg` text of the spec
+ * that generated domain code turns into a `msg` call, with the same message id (`$msgId`, or the id
+ * Lingui generates from the text). Lingui extracts the project's catalogues from `.phoenix`, so the
+ * YAML texts reach them through this file. Nothing imports it.
+ */
+export declare const generateApplicationSpecMessagesFile: (spec: SpecMessagesSpec) => string;

package/dist/application-spec/generate-application/code/templates/spec-messages/spec-messages.js

@@ -0,0 +1,6 @@
+import{isMsgMarker as e,stringifyMsgMacroCode as t}from"../../../../core/index.js";import{CodeImports as s,autoHeader as o}from"../../common/index.js";let n=(e,t)=>{"msg"===e.kind?t.push(e.marker):"array"===e.kind?e.items.forEach(e=>n(e,t)):"object"===e.kind&&e.entries.forEach(([,e])=>n(e,t))},a=(t,s)=>{e(t)?s.push(t):Array.isArray(t)?t.forEach(e=>a(e,s)):"object"==typeof t&&null!==t&&Object.values(t).forEach(e=>a(e,s))},r=(e,t)=>{for(let s of e.expressions.expressions.values())for(let e of s.values())"value"===e.implementation.kind&&n(e.implementation.plan.template,t);for(let s of e.components)"userBound"===s.implementation.kind&&n(s.implementation.plan.template,t);for(let s of Object.values(e.invariants.entries))for(let e of Object.values(s))"static"===e.kind&&"string"!=typeof e.message&&t.push(e.message);a(e.defaults.entries,t)};export const generateApplicationSpecMessagesFile=e=>{let n=[];r(e.configurator,n),r(e.admin,n);let a=[...new Set(n.map(t))],i=new s;return a.length>0&&i.addImport("@lingui/core/macro","msg"),`${o("spec-messages.ts","The texts of the spec as msg calls, for Lingui extraction.")}
+${i.toString()}
+
+export const specMessages = [${a.map(e=>`
+  ${e},`).join("")}${a.length>0?"\n":""}]
+`};

package/dist/application-spec/generate-application/runtime/admin-runtime/admin-model-runtime.d.ts

@@ -1,7 +1,8 @@
 import { Branded } from '@salsita-ai/common/utils';
 import { type $DomainEntity, $DomainEntityReflection, DomainBuilder, type DomainEntity, DomainEntityReflection, RawAliasReflection, SchemaReflection } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { DataSchemas, Expressions, ModelVersion, ResolvedVersions } from '../../../parse-application-files/index.js';
+import type { DataSchemas, Expressions } from '../../../parse-application-files/index.js';
+import type { RuntimeModelVersion, RuntimeResolvedVersions } from '../../runtime-spec/index.js';
 type AnyEntity = DomainEntity<string>;
 type AnyAliases = Record<string, AnyEntity>;
 type AnyData = Record<string, unknown>;
@@ -9,8 +10,8 @@ type Any$Map = Record<AnyEntity['type'], $DomainEntity<AnyEntity>>;
 type AnyDomainBuilder = DomainBuilder<AnyEntity, AnyEntity, AnyAliases, Any$Map, AnyData, AnyData, AnyData>;
 interface AdminModelRuntimeSpec {
     readonly expressions: Expressions;
-    readonly latestModel: ModelVersion;
-    readonly resolvedVersions: ResolvedVersions;
+    readonly latestModel: RuntimeModelVersion;
+    readonly resolvedVersions: RuntimeResolvedVersions;
 }
 interface AdminModelRuntimeFields {
     readonly entities: Record<string, DomainEntityReflection<AnyEntity>>;

package/dist/application-spec/generate-application/runtime/admin-runtime/admin-runtime.d.ts

@@ -1,6 +1,6 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 import { FactoryDataRuntime } from '../factory-data/index.js';
 import { type MigrationModules, MigrationRuntime } from '../migrations/index.js';
 import { ComponentOptics } from '../sections/component-optic.js';
@@ -24,4 +24,4 @@ export type AdminRuntimeResult = {
     readonly ok: false;
     readonly missingExpressions: readonly MissingExpression[];
 };
-export declare const AdminRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, invariantImplementations: InvariantImplementations, migrationModules: MigrationModules) => AdminRuntimeResult;
+export declare const AdminRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, invariantImplementations: InvariantImplementations, migrationModules: MigrationModules) => AdminRuntimeResult;

package/dist/application-spec/generate-application/runtime/admin-runtime/states-runtime.d.ts

@@ -1,8 +1,8 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 export type AdminStatesRuntime = Branded<'AdminStatesRuntime', {
     readonly navigationStates: readonly string[];
     readonly changed: boolean;
 }>;
-export declare const AdminStatesRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore) => AdminStatesRuntime;
+export declare const AdminStatesRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => AdminStatesRuntime;

package/dist/application-spec/generate-application/runtime/application-runtime.d.ts

@@ -1,15 +1,15 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { ImportedTransformer } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../caching/index.js';
-import type { ApplicationSpec } from '../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../runtime-spec/index.js';
 import { AdminRuntime } from './admin-runtime/admin-runtime.js';
 import { ConfiguratorRuntime } from './configurator-runtime/configurator-runtime.js';
 import type { MigrationModules } from './migrations/index.js';
 import { DataRuntime } from './sections/data-runtime.js';
 import type { ExpressionImplementations, InvariantImplementations, MissingExpression } from './sections/expression-runtime.js';
 /**
- * Runtime objects built from ApplicationSpec.
- * Domain-specific fields mirror ApplicationSpec configurator/admin nesting.
+ * Runtime objects built from a RuntimeSpec.
+ * Domain-specific fields mirror the spec's configurator/admin nesting.
  */
 export type ApplicationRuntime = Branded<'ApplicationRuntime', {
     readonly configurator: ConfiguratorRuntime;
@@ -24,7 +24,8 @@ export type ApplicationRuntimeResult = {
     readonly missingExpressions: readonly MissingExpression[];
 };
 /**
- * Builds an ApplicationRuntime from an ApplicationSpec.
+ * Builds an ApplicationRuntime from a RuntimeSpec: the part of the parsed spec the runtime reads, which a
+ * parsed ApplicationSpec also is.
  * A persistent RuntimeReferenceStore preserves per-item references and reports
  * section-level changes across rebuilds.
  * Each field on the result carries its own `changed` flag.
@@ -37,4 +38,4 @@ export type ApplicationRuntimeResult = {
  *
  * Returns an error result when declared expressions are missing implementations.
  */
-export declare const ApplicationRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, importedTransformers: readonly ImportedTransformer[], invariantImplementations?: InvariantImplementations, adminImplementations?: ExpressionImplementations, adminInvariantImplementations?: InvariantImplementations, migrationModules?: MigrationModules) => ApplicationRuntimeResult;
+export declare const ApplicationRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, importedTransformers: readonly ImportedTransformer[], invariantImplementations?: InvariantImplementations, adminImplementations?: ExpressionImplementations, adminInvariantImplementations?: InvariantImplementations, migrationModules?: MigrationModules) => ApplicationRuntimeResult;

package/dist/application-spec/generate-application/runtime/configurator-runtime/configurator-model-runtime.d.ts

@@ -1,7 +1,8 @@
 import { Branded } from '@salsita-ai/common/utils';
 import { type $DomainEntity, $DomainEntityReflection, DomainBuilder, type DomainEntity, DomainEntityReflection, RawAliasReflection, SchemaReflection } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { DataSchemas, Expressions, ModelVersion, ResolvedVersions } from '../../../parse-application-files/index.js';
+import type { DataSchemas, Expressions } from '../../../parse-application-files/index.js';
+import type { RuntimeModelVersion, RuntimeResolvedVersions } from '../../runtime-spec/index.js';
 type AnyEntity = DomainEntity<string>;
 type AnyAliases = Record<string, AnyEntity>;
 type AnyData = Record<string, unknown>;
@@ -10,8 +11,8 @@ type AnyDomainBuilder = DomainBuilder<AnyEntity, AnyEntity, AnyAliases, Any$Map,
 interface ConfiguratorModelRuntimeSpec {
     readonly dataSchemas: DataSchemas;
     readonly expressions: Expressions;
-    readonly latestModel: ModelVersion;
-    readonly resolvedVersions: ResolvedVersions;
+    readonly latestModel: RuntimeModelVersion;
+    readonly resolvedVersions: RuntimeResolvedVersions;
 }
 interface ConfiguratorModelRuntimeFields {
     readonly entities: Record<string, DomainEntityReflection<AnyEntity>>;

package/dist/application-spec/generate-application/runtime/configurator-runtime/configurator-runtime.d.ts

@@ -1,7 +1,7 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { ImportedTransformer } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 import { FactoryDataRuntime } from '../factory-data/index.js';
 import { type MigrationModules, MigrationRuntime } from '../migrations/index.js';
 import { ActionsRuntime } from '../sections/actions-runtime.js';
@@ -33,4 +33,4 @@ export type ConfiguratorRuntimeResult = {
     readonly ok: false;
     readonly missingExpressions: readonly MissingExpression[];
 };
-export declare const ConfiguratorRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, importedTransformers: readonly ImportedTransformer[], invariantImplementations: InvariantImplementations | undefined, migrationModules: MigrationModules) => ConfiguratorRuntimeResult;
+export declare const ConfiguratorRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, implementations: ExpressionImplementations, importedTransformers: readonly ImportedTransformer[], invariantImplementations: InvariantImplementations | undefined, migrationModules: MigrationModules) => ConfiguratorRuntimeResult;

package/dist/application-spec/generate-application/runtime/configurator-runtime/states-runtime.d.ts

@@ -1,6 +1,6 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 export type ConfiguratorStatesRuntime = Branded<'ConfiguratorStatesRuntime', {
     readonly navigationStates: readonly string[];
     readonly viewStates: readonly string[];
@@ -8,4 +8,4 @@ export type ConfiguratorStatesRuntime = Branded<'ConfiguratorStatesRuntime', {
     readonly exportStates: readonly string[];
     readonly changed: boolean;
 }>;
-export declare const ConfiguratorStatesRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore) => ConfiguratorStatesRuntime;
+export declare const ConfiguratorStatesRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => ConfiguratorStatesRuntime;

package/dist/application-spec/generate-application/runtime/migrations/migration-runtime.d.ts

@@ -1,7 +1,7 @@
 import { Branded } from '@salsita-ai/common/utils';
 import { type AnyEntityReflections, type DomainEntity, type MigrateFunction, type Migration } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ResolvedVersions } from '../../../parse-application-files/index.js';
+import type { RuntimeResolvedVersions } from '../../runtime-spec/index.js';
 type AnyEntity = DomainEntity<string>;
 type AnyMigration = Migration<AnyEntity, AnyEntity>;
 /**
@@ -35,7 +35,7 @@ interface MigrationRuntimeFields {
  */
 export type MigrationRuntime = Branded<'MigrationRuntime', MigrationRuntimeFields>;
 interface MigrationRuntimeInput {
-    readonly resolvedVersions: ResolvedVersions;
+    readonly resolvedVersions: RuntimeResolvedVersions;
     readonly latestEntities: AnyEntityReflections;
     readonly migrationModules: MigrationModules;
 }

package/dist/application-spec/generate-application/runtime/sections/assistant-runtime.d.ts

@@ -1,10 +1,10 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { AssistantResolvedManifest } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 /** Resolved assistant manifest with change tracking, carried to the runtime spec on hot reload. */
 export type AssistantRuntime = Branded<'AssistantRuntime', {
     readonly assistant: AssistantResolvedManifest | null;
     readonly changed: boolean;
 }>;
-export declare const AssistantRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore) => AssistantRuntime;
+export declare const AssistantRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => AssistantRuntime;

package/dist/application-spec/generate-application/runtime/sections/data-runtime.d.ts

@@ -1,13 +1,13 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
-type ParsedDataSpecEntries = ApplicationSpec['dataSpec']['entries'];
-type ParsedChunks = ApplicationSpec['dataSpec']['chunks'];
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
+type ParsedDataSpecEntries = RuntimeSpec['dataSpec']['entries'];
+type ParsedChunks = RuntimeSpec['dataSpec']['chunks'];
 export type DataRuntime = Branded<'DataRuntime', {
     readonly dataSpec: ParsedDataSpecEntries;
     readonly chunks: ParsedChunks;
     readonly publishedDataHash: string;
     readonly changed: boolean;
 }>;
-export declare const DataRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore) => DataRuntime;
+export declare const DataRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => DataRuntime;
 export {};

package/dist/application-spec/generate-application/runtime/sections/expression-runtime.d.ts

@@ -1,7 +1,8 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { DomainEntity, Expression as DomainExpression, Invariant as DomainInvariant } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { Expressions, ModelVersion } from '../../../parse-application-files/index.js';
+import type { Expressions } from '../../../parse-application-files/index.js';
+import type { RuntimeModelVersion } from '../../runtime-spec/index.js';
 type RuntimeData = Record<string, unknown>;
 type RuntimeEntity = DomainEntity<string>;
 type AnyExpression = DomainExpression<RuntimeEntity, RuntimeEntity, RuntimeData, RuntimeData, RuntimeData, RuntimeEntity, unknown>;
@@ -30,7 +31,7 @@ export type ExpressionRuntimeResult = {
 };
 interface ExpressionRuntimeSpec {
     readonly expressions: Expressions;
-    readonly latestModel: ModelVersion;
+    readonly latestModel: RuntimeModelVersion;
 }
 /**
  * Runtime section that produces the single merged expression map for the registry.

package/dist/application-spec/generate-application/runtime/sections/theme-runtime.d.ts

@@ -1,10 +1,10 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 /** Resolved theme spec with change tracking — no UI deps, just preset + options. */
 export type ThemeRuntime = Branded<'ThemeRuntime', {
     readonly preset: string;
     readonly options: Readonly<Record<string, unknown>>;
     readonly changed: boolean;
 }>;
-export declare const ThemeRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore) => ThemeRuntime;
+export declare const ThemeRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => ThemeRuntime;

package/dist/application-spec/generate-application/runtime/sections/transformers-runtime.d.ts

@@ -1,7 +1,7 @@
 import { Branded } from '@salsita-ai/common/utils';
 import type { ImportedTransformer } from '#package/domain';
 import type { RuntimeReferenceStore } from '../../../caching/index.js';
-import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
 /**
  * Runtime section for transformers. Combines two sources of truth:
  * - `importedTransformers` — factory functions from src/transformers/*.ts
@@ -13,7 +13,7 @@ import type { ApplicationSpec } from '../../../parse-application-files/index.js'
  */
 export type TransformersRuntime = Branded<'TransformersRuntime', {
     readonly importedTransformers: readonly ImportedTransformer[];
-    readonly specTransformers: ApplicationSpec['configurator']['transformers'];
+    readonly specTransformers: RuntimeSpec['configurator']['transformers'];
     readonly changed: boolean;
 }>;
-export declare const TransformersRuntime: (spec: ApplicationSpec, referenceStore: RuntimeReferenceStore, importedTransformers: readonly ImportedTransformer[]) => TransformersRuntime;
+export declare const TransformersRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, importedTransformers: readonly ImportedTransformer[]) => TransformersRuntime;

package/dist/application-spec/generate-application/runtime-spec/decode-runtime-spec.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeSpec } from './runtime-spec.js';
+/**
+ * Reads the JSON text of `.phoenix/application-spec.json` back into the runtime spec that
+ * `encodeRuntimeSpec` wrote: one `JSON.parse`, then each listed array back into its Map or Set.
+ *
+ * Throws when the text is not a runtime spec artifact, or when it was written in another format
+ * version than this SDK reads; `phoenix sync` writes the artifact again in the right one.
+ */
+export declare const decodeRuntimeSpec: (text: string) => RuntimeSpec;

package/dist/application-spec/generate-application/runtime-spec/decode-runtime-spec.js

@@ -0,0 +1 @@
+import{RUNTIME_SPEC_FORMAT_VERSION as e}from"./encoded-runtime-spec.js";let t="Run `phoenix sync` to write it again with the SDK the project uses.",r=e=>"object"==typeof e&&null!==e,i=e=>Error(`Cannot read .phoenix/application-spec.json: its ${e.kind} at ${JSON.stringify(e.path)} is not where the file says it is, so the file was changed after it was written. ${t}`),o=(e,t)=>{let o=e,n="spec";for(let e of t.path)o=r(o)?o[n]:void 0,n=e;let s=r(o)?o[n]:void 0;if(!r(o)||!Array.isArray(s))throw i(t);o[n]="Map"===t.kind?new Map(s.map(e=>{if(!Array.isArray(e)||2!==e.length)throw i(t);return[e[0],e[1]]})):new Set(s)};export const decodeRuntimeSpec=i=>{let n=JSON.parse(i);if(!(r(n)&&"number"==typeof n.format&&Array.isArray(n.collections)&&"spec"in n))throw Error(`Cannot read .phoenix/application-spec.json: it is not a runtime spec written by \`phoenix sync\` or \`phoenix build\`. ${t}`);if(n.format!==e)throw Error(`Cannot read .phoenix/application-spec.json: it is written in format version ${n.format}, and this SDK reads format version ${e}, so it was written by another version of the SDK. ${t}`);let s={spec:n.spec};for(let e of n.collections)o(s,e);return s.spec};

package/dist/application-spec/generate-application/runtime-spec/encode-runtime-spec.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeSpec } from './runtime-spec.js';
+/**
+ * Writes a runtime spec as the JSON text of `.phoenix/application-spec.json`, which
+ * `decodeRuntimeSpec` reads back. Maps and Sets become arrays listed in `collections`, properties
+ * whose value is `undefined` are left out, and the document carries the format version. The text
+ * is the same for the same spec, so an unchanged spec leaves the file unchanged.
+ */
+export declare const encodeRuntimeSpec: (spec: RuntimeSpec) => string;

package/dist/application-spec/generate-application/runtime-spec/encode-runtime-spec.js

@@ -0,0 +1 @@
+import{RUNTIME_SPEC_FORMAT_VERSION as t}from"./encoded-runtime-spec.js";let e=(t,e)=>Error(`Cannot write .phoenix/application-spec.json: the parsed spec holds ${e} at ${JSON.stringify(t.path)}, which the runtime spec cannot hold. The runtime spec holds only plain data, Maps and Sets, so the parser produced a value it should not have. Report this to the Phoenix team with the YAML that declares this value.`),o=(t,e,o)=>{t.path.push(e);let n=r(t,o);return t.path.pop(),n},r=(t,r)=>{let n;if(null===r||"string"==typeof r||"boolean"==typeof r)return r;if("number"==typeof r){if(!Number.isFinite(r))throw e(t,`the number ${r}`);return r}if("object"!=typeof r)throw e(t,`a value of type ${typeof r}`);if(r instanceof Map){let e=[...r].map(([e,r],n)=>{t.path.push(n);let p=[o(t,0,e),o(t,1,r)];return t.path.pop(),p});return t.collections.push({kind:"Map",path:[...t.path]}),e}if(r instanceof Set){let e=[...r].map((e,r)=>o(t,r,e));return t.collections.push({kind:"Set",path:[...t.path]}),e}if(Array.isArray(r))return r.map((r,n)=>{if(void 0===r)throw e(t,`undefined as item ${n} of an array`);return o(t,n,r)});if((n=Object.getPrototypeOf(r))!==Object.prototype&&null!==n)throw e(t,`an instance of ${r.constructor.name}`);let p={};for(let[e,n]of Object.entries(r))void 0!==n&&(p[e]=o(t,e,n));return p};export const encodeRuntimeSpec=e=>{let o={path:[],collections:[]},n=r(o,e);return JSON.stringify({format:t,collections:o.collections,spec:n})};

package/dist/application-spec/generate-application/runtime-spec/encoded-runtime-spec.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The version of the JSON format `encodeRuntimeSpec` writes. Raise it with every change to the
+ * format or to the shape of `RuntimeSpec`, so that `decodeRuntimeSpec` refuses an artifact an older
+ * or newer SDK wrote instead of building a runtime from data it does not understand.
+ */
+export declare const RUNTIME_SPEC_FORMAT_VERSION = 1;
+/** One step from a value into a part of it: an object key or an array index. */
+export type RuntimeSpecPathSegment = string | number;
+/**
+ * A Map or Set of the runtime spec, which JSON cannot hold: it is written as an array (a Map as its
+ * `[key, value]` entries), and `path` leads from the spec to that array. Paths into a Map run
+ * through its entries, so `[..., 2, 1]` is the value of its third entry.
+ */
+export interface EncodedCollection {
+    readonly kind: 'Map' | 'Set';
+    readonly path: readonly RuntimeSpecPathSegment[];
+}
+/**
+ * The JSON document of `.phoenix/application-spec.json`. `spec` is the runtime spec with every Map
+ * and Set written as an array, and `collections` lists those arrays, inner ones before the ones
+ * that hold them, so a decoder turns them back in that order without walking the whole spec.
+ */
+export interface EncodedRuntimeSpec {
+    readonly format: number;
+    readonly collections: readonly EncodedCollection[];
+    readonly spec: unknown;
+}

package/dist/application-spec/generate-application/runtime-spec/encoded-runtime-spec.js

@@ -0,0 +1 @@
+export const RUNTIME_SPEC_FORMAT_VERSION=1;

package/dist/application-spec/generate-application/runtime-spec/index.d.ts

@@ -0,0 +1,5 @@
+export * from './runtime-spec.js';
+export * from './encoded-runtime-spec.js';
+export * from './encode-runtime-spec.js';
+export * from './decode-runtime-spec.js';
+export * from './spec-code-id.js';

package/dist/application-spec/generate-application/runtime-spec/index.js

@@ -0,0 +1 @@
+export*from"./runtime-spec.js";export*from"./encoded-runtime-spec.js";export*from"./encode-runtime-spec.js";export*from"./decode-runtime-spec.js";export*from"./spec-code-id.js";

package/dist/application-spec/generate-application/runtime-spec/runtime-spec.d.ts

@@ -0,0 +1,68 @@
+import type { AdminSpec, ApplicationSpec, ConfiguratorSpec, EntitySchema, Infra, ModelVersion, ResolvedModelVersion, ResolvedVersions } from '../../parse-application-files/index.js';
+/**
+ * The part of a parsed entity schema the runtime reads: the entity type and the schema of its
+ * shape, from which it builds the entity's reflection. The full schema with `id` and `type` is
+ * only registered with a deployment, and the compiled shape validators only check presets and
+ * defaults while parsing.
+ */
+export type RuntimeEntitySchema = Pick<EntitySchema, 'entityType' | 'shapeSchema'>;
+/**
+ * The part of a parsed model version the runtime reads: the entity types, the aliases, the common
+ * types and the schema of every entity's shape. The raw shapes and resolved shapes only serve the
+ * parser and the type generator.
+ */
+export type RuntimeModelVersion = Pick<ModelVersion, 'versionKey' | 'entityTypes' | 'rootEntityTypes' | 'aliases' | 'commonTypes'> & {
+    readonly entitySchemas: readonly RuntimeEntitySchema[];
+};
+/** One model version of a domain as the runtime reads it, with the migration file that leads to it. */
+export type RuntimeResolvedModelVersion = Omit<ResolvedModelVersion, 'modelVersion'> & {
+    readonly modelVersion: RuntimeModelVersion;
+};
+/** Every model version of a domain as the runtime reads it; it builds the domain's migrations from them. */
+export type RuntimeResolvedVersions = Pick<ResolvedVersions, 'latestVersion'> & {
+    readonly versionedModels: readonly RuntimeResolvedModelVersion[];
+};
+/** The model of a domain as the runtime reads it: the latest version and every earlier one. */
+interface RuntimeDomainModel {
+    readonly latestModel: RuntimeModelVersion;
+    readonly resolvedVersions: RuntimeResolvedVersions;
+}
+/**
+ * The configurator part of the runtime spec. It leaves out the configuration schema and its
+ * version, which only a deployment registers, and the assistant's server settings (instructions
+ * and AI settings), which must never reach the browser of a customer.
+ */
+export type RuntimeConfiguratorSpec = Pick<ConfiguratorSpec, 'components' | 'presets' | 'expressions' | 'actions' | 'invariants' | 'dataSchemas' | 'defaults' | 'states' | 'theme' | 'ui' | 'transformers' | 'assistant'> & RuntimeDomainModel;
+/**
+ * The admin part of the runtime spec. It leaves out the configuration schema and its version, which
+ * only a deployment registers.
+ */
+export type RuntimeAdminSpec = Pick<AdminSpec, 'components' | 'presets' | 'expressions' | 'invariants' | 'defaults' | 'states' | 'adminPages'> & RuntimeDomainModel;
+/**
+ * The infrastructure settings the runtime reads: access control and resources. The environment
+ * variable declarations only drive the generated environment readers.
+ */
+export type RuntimeInfra = Pick<Infra, 'acl' | 'resources' | 'resourcesConfig'>;
+/**
+ * The parsed application spec as the runtime reads it: what `ApplicationRuntime` builds the
+ * configurator and admin runtimes from, and the sections an application needs besides its domains
+ * (data spec, app metadata, resources, access control, user interface settings, webhook data
+ * schemas, admin pages). `phoenix sync` and `phoenix build` write it to
+ * `.phoenix/application-spec.json` with `encodeRuntimeSpec`.
+ *
+ * It is derived from the parsed types, so a section the runtime reads keeps the parser's type. It
+ * leaves out what only the parser, the type generator or a deployment use, and holds plain data,
+ * Maps and Sets only, so it can be encoded as JSON.
+ */
+export interface RuntimeSpec extends Pick<ApplicationSpec, 'appMetadata' | 'dataSpec'> {
+    readonly configurator: RuntimeConfiguratorSpec;
+    readonly admin: RuntimeAdminSpec;
+    readonly infra: RuntimeInfra;
+}
+/**
+ * Takes from a parsed application spec the part the runtime reads. The sections it keeps are the
+ * parsed values themselves, not copies; only the model versions are rebuilt without what the
+ * runtime does not read.
+ */
+export declare const toRuntimeSpec: (spec: ApplicationSpec) => RuntimeSpec;
+export {};

package/dist/application-spec/generate-application/runtime-spec/runtime-spec.js

@@ -0,0 +1 @@
+let e=e=>({versionKey:e.versionKey,entityTypes:e.entityTypes,rootEntityTypes:e.rootEntityTypes,aliases:e.aliases,commonTypes:e.commonTypes,entitySchemas:e.entitySchemas.map(e=>({entityType:e.entityType,shapeSchema:e.shapeSchema}))}),s=s=>({latestModel:e(s.latestModel),resolvedVersions:{latestVersion:s.resolvedVersions.latestVersion,versionedModels:s.resolvedVersions.versionedModels.map(s=>({version:s.version,key:s.key,isLatest:s.isLatest,migrationFile:s.migrationFile,modelVersion:e(s.modelVersion)}))}});export const toRuntimeSpec=e=>{let{configurator:t,admin:a,infra:n}=e;return{configurator:{components:t.components,presets:t.presets,expressions:t.expressions,actions:t.actions,invariants:t.invariants,dataSchemas:t.dataSchemas,defaults:t.defaults,states:t.states,theme:t.theme,ui:t.ui,transformers:t.transformers,assistant:t.assistant,...s(t)},admin:{components:a.components,presets:a.presets,expressions:a.expressions,invariants:a.invariants,defaults:a.defaults,states:a.states,adminPages:a.adminPages,...s(a)},appMetadata:e.appMetadata,infra:{acl:n.acl,resources:n.resources,resourcesConfig:n.resourcesConfig},dataSpec:e.dataSpec}};

package/dist/application-spec/generate-application/runtime-spec/spec-code-id.d.ts

@@ -0,0 +1,40 @@
+import type { MemoEvalPlan } from '../../parse-application-files/index.js';
+/**
+ * The id under which the generated `.phoenix/spec-code.ts` holds one piece of code written in YAML,
+ * and under which the runtime looks it up. Ids are unique within one domain; the configurator and
+ * the admin domain each have their own map.
+ *
+ * An id is computed from what the runtime spec already carries, by the functions of this file, on
+ * both sides: the generator that writes the closures and the runtime that reads them. It names the
+ * entity or alias that owns the code, the expression or the component instance, the position of the
+ * code inside that one value, and a hash of the code's text. So it stays the same when anything
+ * else in the spec changes, and it changes whenever the code itself changes: a module generated from
+ * another version of the spec does not hold it, and the runtime compiles the text instead of running
+ * the wrong closure.
+ */
+export type SpecCodeId = string;
+/**
+ * The part of an id that names a value expression: `KitchenRange.$maxWidth`. Its constant, when it
+ * is one, shares the plan and so the ids.
+ */
+export declare const specCodeExpressionKey: (typeOrAlias: string, expressionName: string) => string;
+/**
+ * The part of an id that names a component instance: `KitchenRange.main:detail`. The component
+ * belongs to it because an instance name is unique per component, not per entity: one entity can
+ * attach `main` of several components.
+ */
+export declare const specCodeComponentKey: (typeOrAlias: string, instanceName: string, componentName: string) => string;
+/**
+ * The id of each dependency of a plan, by dependency index: `<key>#<n>@<hash>` for the `n`-th
+ * `$eval` dependency, `undefined` for a read. `key` is the expression or component key of the value
+ * the plan builds. The ordinal counts the plan's `$eval` dependencies only, so a `$read` added to
+ * the same value does not renumber them.
+ */
+export declare const specCodeEvalIds: (plan: MemoEvalPlan, key: string) => ReadonlyArray<SpecCodeId | undefined>;
+/**
+ * Id of the `$eval` of one filter criterion of a component instance:
+ * `KitchenRange.label:textValue#filter0.active@<hash>`. `componentKey` comes from
+ * {@link specCodeComponentKey}; `branch` is the index of the filter among the `$or` alternatives,
+ * 0 when the filter has none; `code` is the criterion's code.
+ */
+export declare const specCodeFilterId: (componentKey: string, branch: number, criterion: string, code: string) => SpecCodeId;

package/dist/application-spec/generate-application/runtime-spec/spec-code-id.js

@@ -0,0 +1 @@
+let e=e=>{let t=e.trim(),o=0x811c9dc5;for(let e=0;e<t.length;e++)o^=t.charCodeAt(e),o=Math.imul(o,0x1000193)>>>0;return o.toString(16).padStart(8,"0")};export const specCodeExpressionKey=(e,t)=>`${e}.${t}`;export const specCodeComponentKey=(e,t,o)=>`${e}.${t}:${o}`;export const specCodeEvalIds=(t,o)=>{let r=0;return t.deps.map(t=>"eval"===t.kind?`${o}#${r++}@${e(t.code)}`:void 0)};export const specCodeFilterId=(t,o,r,d)=>`${t}#filter${o}.${r}@${e(d)}`;

package/dist/application-spec/parse-application-files/categorize/categorize-files.d.ts

@@ -80,6 +80,24 @@ export type CategorizedFiles = Branded<'CategorizedFiles', {
      * any other root `tsconfig.json` is the project's own and is left as it is.
      */
     readonly hasEarlierGeneratedTsconfig: boolean;
+    /**
+     * One-time migration: true only on a checkout's first sync with an SDK that contains this field;
+     * delete it once projects have synced with such an SDK.
+     *
+     * Whether the project's root `eslint.config.js` is the file earlier SDK versions generated on
+     * every sync, before it became the project's. Generation reads it to replace that file once with
+     * the current one; any other root `eslint.config.js` is the project's own and is left as it is.
+     */
+    readonly hasEarlierGeneratedEslintConfig: boolean;
+    /**
+     * One-time migration: true only on a checkout's first sync with an SDK that contains this field;
+     * delete it once projects have synced with such an SDK.
+     *
+     * Whether the project's root `prettier.config.js` is the file earlier SDK versions generated on
+     * every sync, before it became the project's. Generation reads it to replace that file once with
+     * the current one; any other root `prettier.config.js` is the project's own and is left as it is.
+     */
+    readonly hasEarlierGeneratedPrettierConfig: boolean;
     readonly customCode: readonly CategorizedFile[];
     readonly customCodeChanged: boolean;
     readonly envs: Record<string, unknown>;