@salsita-ai/sdk 0.0.0-stage → 0.49.0-develop.cbee856178

package/dist/application-spec/parse-application-files/raw-spec/raw-resources.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+declare const rawConfigurationLinkSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ConfigurationLink">;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "ConfigurationLink";
+    name: string;
+}, {
+    type: "ConfigurationLink";
+    name: string;
+}>;
+declare const rawCsvSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Csv">;
+    name: z.ZodString;
+    s3Key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "Csv";
+    name: string;
+    s3Key?: string | undefined;
+}, {
+    type: "Csv";
+    name: string;
+    s3Key?: string | undefined;
+}>;
+declare const rawPdfSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Pdf">;
+    name: z.ZodString;
+    s3Key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "Pdf";
+    name: string;
+    s3Key?: string | undefined;
+}, {
+    type: "Pdf";
+    name: string;
+    s3Key?: string | undefined;
+}>;
+export type RawConfigurationLinkResource = Readonly<z.infer<typeof rawConfigurationLinkSchema>>;
+export type RawCsvResource = Readonly<z.infer<typeof rawCsvSchema>>;
+export type RawPdfResource = Readonly<z.infer<typeof rawPdfSchema>>;
+export interface RawClientGeneratedImageResource {
+    readonly type: 'Image';
+    readonly name: string;
+    readonly clientGenerated: true;
+    readonly s3Key: string;
+}
+export interface RawExistingImageResource {
+    readonly type: 'Image';
+    readonly name: string;
+    readonly exists: true;
+    readonly url: string;
+}
+export interface RawGeneratedImageResource {
+    readonly type: 'Image';
+    readonly name: string;
+    readonly s3Key: string;
+}
+export type RawImageResource = RawClientGeneratedImageResource | RawExistingImageResource | RawGeneratedImageResource;
+export type RawResourceEntry = RawConfigurationLinkResource | RawCsvResource | RawPdfResource | RawImageResource;
+export declare const rawResourcesSchema: z.ZodType<readonly RawResourceEntry[]>;
+export type RawResourcesConfig = {
+    readonly baseResourcesUrl?: string;
+    readonly prefetchTextureUrls?: readonly string[];
+    readonly deploymentQueryDisabled?: boolean;
+};
+export declare const rawResourcesConfigSchema: z.ZodType<RawResourcesConfig>;
+export {};

package/dist/application-spec/parse-application-files/raw-spec/raw-resources.js

@@ -0,0 +1 @@
+import{z as e}from"zod";let s=e.object({type:e.literal("ConfigurationLink"),name:e.string()}),t=e.object({type:e.literal("Csv"),name:e.string(),s3Key:e.string().optional()}),r=e.object({type:e.literal("Pdf"),name:e.string(),s3Key:e.string().optional()}),o=e.object({type:e.literal("Image"),name:e.string(),clientGenerated:e.literal(!0).optional(),exists:e.literal(!0).optional(),s3Key:e.string().optional(),url:e.string().optional()}),a=o.superRefine((s,t)=>{let r=!0===s.clientGenerated,o=!0===s.exists,a=void 0!==s.s3Key,i=void 0!==s.url;if(r&&o)return void t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource cannot set both clientGenerated and exists. Pick one variant: clientGenerated+s3Key, exists+url, or bare server-rendered with s3Key."});if(r){a||t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource with clientGenerated: true must include s3Key.",path:["s3Key"]}),i&&t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource with clientGenerated: true cannot include url.",path:["url"]});return}if(o){i||t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource with exists: true must include url.",path:["url"]}),a&&t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource with exists: true cannot include s3Key.",path:["s3Key"]});return}a||t.addIssue({code:e.ZodIssueCode.custom,message:"Image resource requires either clientGenerated: true + s3Key, exists: true + url, or a bare server-rendered image with s3Key.",path:["s3Key"]}),i&&t.addIssue({code:e.ZodIssueCode.custom,message:"Server-rendered Image resource cannot include url — set exists: true to use an external url.",path:["url"]})}),i=e.discriminatedUnion("type",[s,t,r,o]);export const rawResourcesSchema=e.array(i.superRefine((e,s)=>{if("Image"!==e.type)return;let t=a.safeParse(e);if(!t.success)for(let e of t.error.issues)s.addIssue(e)}));export const rawResourcesConfigSchema=e.object({baseResourcesUrl:e.string().optional(),prefetchTextureUrls:e.array(e.string()).optional(),deploymentQueryDisabled:e.boolean().optional()});

package/dist/application-spec/parse-application-files/raw-spec/raw-spec-file.d.ts

@@ -0,0 +1,90 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonObjectSchemaType, type ParseContext } from '../../core/index.js';
+import type { ParsedYamlFile } from './parse-yaml-spec-file.js';
+import { type RawAcl } from './raw-acl.js';
+import { type RawAdminPages } from './raw-admin-pages.js';
+import { type RawAssistant } from './raw-assistant.js';
+import { type RawBudgets } from './raw-budgets.js';
+import { type RawChunks } from './raw-chunks.js';
+import { type RawComponents } from './raw-components.js';
+import { type RawDataSpec } from './raw-data.js';
+import { type RawDefaults } from './raw-defaults.js';
+import { type RawEnv } from './raw-env.js';
+import { type RawExpressions } from './raw-expressions.js';
+import { type RawInvariants } from './raw-invariants.js';
+import { type RawModel } from './raw-model.js';
+import { type RawPresets } from './raw-presets.js';
+import { type RawRelations } from './raw-relations.js';
+import { type RawResourceEntry, type RawResourcesConfig } from './raw-resources.js';
+import { type RawTransformerEntry } from './raw-transformers.js';
+export interface RawSpecContent {
+    readonly $admin?: boolean;
+    readonly model?: RawModel;
+    readonly components?: RawComponents;
+    readonly presets?: RawPresets;
+    readonly $data?: RawDataSpec;
+    readonly expressions?: RawExpressions;
+    readonly invariants?: RawInvariants;
+    readonly relations?: RawRelations;
+    readonly defaults?: RawDefaults;
+    readonly publishedData?: EnhancedJsonObjectSchemaType;
+    readonly sessionData?: EnhancedJsonObjectSchemaType;
+    readonly frontendData?: EnhancedJsonObjectSchemaType;
+    readonly backendData?: EnhancedJsonObjectSchemaType;
+    readonly finalizeData?: EnhancedJsonObjectSchemaType;
+    readonly prefetchedFinalizeData?: EnhancedJsonObjectSchemaType;
+    readonly finalizeResult?: EnhancedJsonObjectSchemaType;
+    readonly callbackData?: EnhancedJsonObjectSchemaType;
+    readonly navigationStates?: readonly string[];
+    readonly viewStates?: readonly string[];
+    readonly toolStates?: readonly string[];
+    readonly exportStates?: readonly string[];
+    readonly themePreset?: string;
+    readonly themeOptions?: Readonly<Record<string, unknown>>;
+    readonly preview?: 'always' | 'never' | 'auto' | 'hide';
+    readonly alwaysExpand?: boolean;
+    readonly availableLocales?: readonly string[];
+    readonly textLanguages?: readonly string[];
+    readonly transformers?: readonly RawTransformerEntry[];
+    /**
+     * The server project this application is developed in: a project slug, or the alias for the default project of
+     * the customer the CLI is signed in to. Read only by the CLI to pick the development environment; it never
+     * reaches the generated application.
+     */
+    readonly project?: string;
+    readonly applicationVersion?: string;
+    readonly workspace?: boolean;
+    readonly webComponentTag?: string;
+    readonly pageTitle?: string;
+    readonly useAuthHook?: boolean;
+    readonly useClerk?: boolean;
+    readonly enableAdminRelease?: boolean;
+    readonly jsonSchemaValidator?: 'ajv' | 'csp-compatible';
+    readonly gltfDecoder?: 'js' | 'wasm';
+    readonly appLoader?: 'legacy' | 'universal';
+    readonly collectFinalizeData?: boolean;
+    readonly env?: RawEnv;
+    readonly acl?: RawAcl;
+    readonly resources?: readonly RawResourceEntry[];
+    readonly resourcesConfig?: RawResourcesConfig;
+    readonly budgets?: RawBudgets;
+    readonly chunks?: RawChunks;
+    readonly assistant?: RawAssistant;
+    readonly $adminPages?: RawAdminPages;
+}
+/**
+ * Top-level sections that each hold one application data schema. Every key is a singleton across
+ * spec files; merge enforces that, and import resolution walks exactly these sections.
+ */
+export declare const DATA_SCHEMA_KEYS: readonly ["publishedData", "sessionData", "frontendData", "backendData", "finalizeData", "prefetchedFinalizeData", "finalizeResult", "callbackData"];
+export type DataSchemaKey = (typeof DATA_SCHEMA_KEYS)[number];
+export type RawSpecFile = Branded<'RawSpecFile', {
+    readonly name: string;
+    readonly content: RawSpecContent;
+}>;
+/**
+ * Validates a parsed YAML object against the loose spec file schema.
+ * Catches structural issues (wrong types, unexpected nesting) but does not enforce
+ * required fields or naming rules — those are checked in later stages.
+ */
+export declare const parseRawSpecFile: (file: ParsedYamlFile, ctx: ParseContext) => RawSpecFile | undefined;

package/dist/application-spec/parse-application-files/raw-spec/raw-spec-file.js

@@ -0,0 +1 @@
+import{z as o}from"zod";import{Branded as a}from"@salsita-ai/common/utils";import{enhancedJsonObjectSchema as t,validateNoLegacyCodeRef as e}from"../../core/index.js";import{DiagnosticCode as n,diagnosticMessages as r}from"../../errors/index.js";import{rawAclSchema as i}from"./raw-acl.js";import{rawAdminPagesSchema as s}from"./raw-admin-pages.js";import{rawAssistantSchema as l}from"./raw-assistant.js";import{rawBudgetsSchema as p}from"./raw-budgets.js";import{rawChunksSchema as m}from"./raw-chunks.js";import{rawComponentsSchema as c}from"./raw-components.js";import{rawConstantsSchema as f}from"./raw-constants.js";import{rawDataSpecSchema as d}from"./raw-data.js";import{rawDefaultsSchema as u}from"./raw-defaults.js";import{rawEnvSchema as j}from"./raw-env.js";import{rawExpressionsSchema as w}from"./raw-expressions.js";import{rawInvariantsSchema as b}from"./raw-invariants.js";import{rawModelSchema as g}from"./raw-model.js";import{rawPresetsSchema as S}from"./raw-presets.js";import{rawRelationsSchema as D}from"./raw-relations.js";import{rawResourcesConfigSchema as h,rawResourcesSchema as v}from"./raw-resources.js";import{rawStateValuesSchema as O}from"./raw-states.js";import{rawTransformersSchema as E}from"./raw-transformers.js";export const DATA_SCHEMA_KEYS=["publishedData","sessionData","frontendData","backendData","finalizeData","prefetchedFinalizeData","finalizeResult","callbackData"];let R=o.object({$admin:o.boolean().optional(),model:g.optional(),components:c.optional(),presets:S.optional(),$data:d.optional(),expressions:w.optional(),invariants:b.optional(),constants:f.optional(),relations:D.optional(),defaults:u.optional(),publishedData:t.optional(),sessionData:t.optional(),frontendData:t.optional(),backendData:t.optional(),finalizeData:t.optional(),prefetchedFinalizeData:t.optional(),finalizeResult:t.optional(),callbackData:t.optional(),navigationStates:O.optional(),viewStates:O.optional(),toolStates:O.optional(),exportStates:O.optional(),themePreset:o.string().optional(),themeOptions:o.record(o.unknown()).optional(),preview:o.enum(["always","never","auto","hide"]).optional(),alwaysExpand:o.boolean().optional(),availableLocales:o.array(o.string()).optional(),textLanguages:o.array(o.string()).optional(),transformers:E.optional(),project:o.string().regex(/^[a-z0-9-]{3,}$/,"must be a project slug (lowercase letters, digits and dashes, at least 3) or `default`").optional(),applicationVersion:o.string().optional(),workspace:o.boolean().optional(),webComponentTag:o.string().optional(),pageTitle:o.string().optional(),useAuthHook:o.boolean().optional(),useClerk:o.boolean().optional(),enableAdminRelease:o.boolean().optional(),jsonSchemaValidator:o.enum(["ajv","csp-compatible"]).optional(),gltfDecoder:o.enum(["js","wasm"]).optional(),appLoader:o.enum(["legacy","universal"]).optional(),collectFinalizeData:o.boolean().optional(),env:j.optional(),acl:i.optional(),resources:v.optional(),resourcesConfig:h.optional(),budgets:p.optional(),chunks:m.optional(),assistant:l.optional(),$adminPages:s.optional()}).strict();export const parseRawSpecFile=(o,t)=>{e(o.content,t);let i=R.safeParse(o.content);if(!i.success){for(let o of i.error.issues)t.error(n.SCHEMA_PARSE_ERROR,r.SCHEMA_PARSE_ERROR(o.path.join("."),o.message));return}let{constants:s,...l}=i.data,p=((o,a)=>{let t=Object.fromEntries(Object.entries(o.expressions??{}).map(([o,a])=>[o,{...a}]));if(void 0===o.constants)return Object.keys(t).length>0?t:void 0;for(let[e,i]of Object.entries(o.constants))for(let[o,s]of(t[e]||(t[e]={}),Object.entries(i))){if(void 0!==t[e][o]){a.at("constants",e,o).error(n.CONSTANTS_EXPRESSION_CONFLICT,r[n.CONSTANTS_EXPRESSION_CONFLICT](e,o));continue}t[e][o]={kind:"value",constant:!0,value:s,schema:{}}}return Object.keys(t).length>0?t:void 0})(i.data,t);return a({name:o.name,content:{...l,expressions:p}})};

package/dist/application-spec/parse-application-files/raw-spec/raw-states.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export type RawStateValues = readonly string[];
+export declare const rawStateValuesSchema: z.ZodArray<z.ZodString, "many">;

package/dist/application-spec/parse-application-files/raw-spec/raw-states.js

@@ -0,0 +1 @@
+import{z as r}from"zod";export const rawStateValuesSchema=r.array(r.string().min(1));

package/dist/application-spec/parse-application-files/raw-spec/raw-transformers.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export interface RawTransformerEntry {
+    readonly name: string;
+    readonly priority?: number;
+}
+export declare const rawTransformersSchema: z.ZodType<readonly RawTransformerEntry[]>;

package/dist/application-spec/parse-application-files/raw-spec/raw-transformers.js

@@ -0,0 +1 @@
+import{z as r}from"zod";export const rawTransformersSchema=r.array(r.object({name:r.string(),priority:r.number().optional()}).strict());

package/dist/application-spec/parse-application-files/resolve/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Spec-file resolution: the parse stage between raw schema validation and merge that resolves
+ * file-relative references — today `import.module` paths — against the project snapshot while the
+ * declaring spec file is still known. Merge consumes `ResolvedSpecFiles`, never `RawSpecFiles`.
+ *
+ * @module
+ */
+export { ResolvedSpecFiles, type ResolvedSpecFile } from './resolved-spec-files.js';

package/dist/application-spec/parse-application-files/resolve/index.js

@@ -0,0 +1 @@
+export{ResolvedSpecFiles}from"./resolved-spec-files.js";

package/dist/application-spec/parse-application-files/resolve/resolve-import-modules.d.ts

@@ -0,0 +1,8 @@
+import { type ParseContext, type ProjectFileIndex } from '../../core/index.js';
+import { type RawSpecContent, type RawSpecFile } from '../raw-spec/index.js';
+/**
+ * Resolves every relative `import.module` in the schemas one spec file declares — model common
+ * types and shapes, expression schemas, and the application data schemas — from the spec file's
+ * own directory into the project-root-relative form described on `ResolvedSpecFile`.
+ */
+export declare const resolveImportModules: (file: RawSpecFile, fileIndex: ProjectFileIndex, ctx: ParseContext) => RawSpecContent;

package/dist/application-spec/parse-application-files/resolve/resolve-import-modules.js

@@ -0,0 +1 @@
+import{mapSchema as e,resolveProjectFileImport as t,resolveProjectPath as r}from"../../core/index.js";import{DiagnosticCode as o,diagnosticMessages as s}from"../../errors/index.js";import{DATA_SCHEMA_KEYS as m}from"../raw-spec/index.js";let n=(m,n,p,i)=>e(m,(e,m)=>e.import?{...e,import:e.import.map((e,a)=>{if(!e.module.startsWith("."))return e;let c=r(n,e.module),O=i.at(...m,"import",String(a),"module");c.escapedProjectRoot?O.warning(o.IMPORT_MODULE_OUTSIDE_PROJECT,s[o.IMPORT_MODULE_OUTSIDE_PROJECT](e.module,c.path)):t(n,e.module,p)||O.error(o.IMPORT_MODULE_NOT_FOUND,s[o.IMPORT_MODULE_NOT_FOUND](e.module,c.path));let d=c.path.startsWith(".")?c.path:`./${c.path}`;return{...e,module:d}})}:e);export const resolveImportModules=(e,t,r)=>{let o=e.content.model?Object.fromEntries(Object.entries(e.content.model).map(([o,s])=>[o,{...s,...s.commonTypes?{commonTypes:Object.fromEntries(Object.entries(s.commonTypes).map(([s,m])=>[s,n(m,e.name,t,r.at("model",o,"commonTypes",s))]))}:{},...s.shapes?{shapes:Object.fromEntries(Object.entries(s.shapes).map(([s,m])=>[s,Object.fromEntries(Object.entries(m).map(([m,p])=>[m,n(p,e.name,t,r.at("model",o,"shapes",s,m))]))]))}:{}}])):void 0,s=e.content.expressions?Object.fromEntries(Object.entries(e.content.expressions).map(([o,s])=>[o,Object.fromEntries(Object.entries(s).map(([s,m])=>[s,{...m,schema:n(m.schema,e.name,t,r.at("expressions",o,s))}]))])):void 0,p=Object.fromEntries(m.flatMap(o=>{let s,m=e.content[o];return m?[[o,{...s=n(m,e.name,t,r.at(o)),type:"object",properties:s.properties??{},required:s.required??[],additionalProperties:!1}]]:[]}));return{...e.content,...o?{model:o}:{},...s?{expressions:s}:{},...p}};

package/dist/application-spec/parse-application-files/resolve/resolved-spec-files.d.ts

@@ -0,0 +1,23 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext, RawProjectFiles } from '../../core/index.js';
+import type { RawSpecContent, RawSpecFiles } from '../raw-spec/index.js';
+/**
+ * One spec file whose file-relative references have been resolved against the project snapshot.
+ *
+ * The content keeps the raw section shapes, but every relative `import.module` is now a
+ * project-root-relative specifier: `./src/…` for an in-project module that was verified to exist,
+ * or `../…` for a path that escapes the project root and could only be warned about. Bare package
+ * specifiers pass through untouched. Code generation rebases these canonical specifiers for the
+ * generated file that imports them, so nothing after this stage needs to know which YAML file
+ * declared the import.
+ *
+ * Resolution runs before merge because merge discards per-file provenance, and a diagnostic for an
+ * unresolved module must name the spec file that declared it.
+ */
+export type ResolvedSpecFile = Branded<'ResolvedSpecFile', {
+    readonly name: string;
+    readonly content: RawSpecContent;
+}>;
+/** Every parsed spec file after resolution — the only input `MergedSpec` accepts. */
+export type ResolvedSpecFiles = Branded<'ResolvedSpecFiles', readonly ResolvedSpecFile[]>;
+export declare const ResolvedSpecFiles: (rawSpecFiles: RawSpecFiles, rawProjectFiles: RawProjectFiles, ctx: ParseContext) => ResolvedSpecFiles;

package/dist/application-spec/parse-application-files/resolve/resolved-spec-files.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{resolveImportModules as m}from"./resolve-import-modules.js";export const ResolvedSpecFiles=(o,t,n)=>{let i=new Set(t.files.map(e=>e.name));return e(o.map(o=>e({name:o.name,content:m(o,i,n.inFile(o.name))})))};

package/dist/application-spec/parse-application-files/spec/application/admin-spec/admin-pages.d.ts

@@ -0,0 +1,30 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+import type { MergedAdminPages } from '../../../merge/index.js';
+import type { RawAdminPages } from '../../../raw-spec/index.js';
+import { type ComponentEntry } from '../../components/index.js';
+import type { ModelVersion } from '../../model/index.js';
+import type { DataSpec } from '../../sections/index.js';
+export type AdminPages = Branded<'AdminPages', {
+    readonly spec: RawAdminPages;
+    readonly components: readonly ComponentEntry[];
+    readonly navigationItems: readonly AdminNavigationItem[];
+    readonly navigationStates: readonly string[];
+}>;
+interface AdminNavigationListItem {
+    readonly label: string;
+    readonly icon?: string;
+    readonly navigationStates: readonly string[];
+}
+interface AdminNestedNavigationListItem {
+    readonly label: string;
+    readonly icon?: string;
+    readonly items: ReadonlyArray<Omit<AdminNavigationListItem, 'icon'>>;
+}
+type AdminNavigationItem = AdminNavigationListItem | AdminNestedNavigationListItem;
+interface AdminPageContext {
+    readonly latestModel: ModelVersion;
+    readonly parsingContext: ParseContext;
+}
+export declare const AdminPages: (merged: MergedAdminPages, context: AdminPageContext, dataSpec?: DataSpec) => AdminPages | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/application/admin-spec/admin-pages.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as a,diagnosticMessages as t}from"../../../../errors/index.js";import{ComponentFilters as i,SdkComponentEntry as n}from"../../components/index.js";import{EntityOrAliasName as r,InstanceName as o}from"../../model/index.js";let s=e=>i({navigationStates:[e]}),m=(e,a)=>i({navigationStates:[e],selectedEntityIds:{$eval:a}}),d=e=>void 0!==e,c=()=>({components:[],navigationItems:[],navigationStates:[]}),l=(e,a)=>{let t=r(e.typeOrAlias,a.parsingContext.at(e.typeOrAlias));if(void 0===t||!a.latestModel.allNames.has(t))return void a.parsingContext.at(e.typeOrAlias).error("ADMIN_PAGE_UNKNOWN_ENTITY",`Admin page entity "${e.typeOrAlias}" is not declared in admin model.`);let i=o(e.instanceName,e.typeOrAlias,e.componentName,a.parsingContext);if(i)return n({typeOrAlias:t,instanceName:i,componentName:e.componentName,implementation:{kind:"sdk",filters:e.filters,readFactory:{sdkFunction:e.readFactory,params:e.readParams??[]},writeFactory:{sdkFunction:e.writeFactory??"createEmptyWrite",params:e.writeParams??[]}}},{aliases:a.latestModel.aliases})},p=(e,a)=>{let{typeOrAliases:t,...i}=e;return t.map(e=>l({...i,typeOrAlias:e},a)).filter(d)},g=e=>Object.fromEntries(e.filter(e=>void 0!==e[1])),y=(e={},a={})=>[e,a],f=e=>Array.isArray(e)?e:"object"==typeof e&&null!==e&&"$lang"in e?{$lang:e.$lang}:e,v=e=>{if(void 0!==e)return e.map(e=>e.map(f))},A=e=>Object.fromEntries(Object.entries(e).map(([e,a])=>[e,Array.isArray(a)?[...a]:"object"==typeof a?g(Object.entries(a).map(([e,a])=>[e,a])):a])),P=e=>"items"in e?{label:e.label,...void 0===e.icon?{}:{icon:e.icon},items:e.items.map(P)}:{label:e.label,...void 0===e.icon?{}:{icon:e.icon},navigationStates:e.navigationStates},S=(e,a,t,i,n,r)=>g([["key",e],["title",a],["generated",t],["icon",i],["values",v(n)],["definition",A(r)]]),N=(e,a)=>e.adminDataPages.some(e=>e.key===a&&"manual"!==e.kind);export const AdminPages=(n,r,o)=>{let f;if(!(n.configured&&(void 0!==(f=n.pages).presets||void 0!==f.recipes&&f.recipes.length>0||void 0!==f.pages||(o?.adminDataPages.length??0)>0)))return e({spec:n.pages,components:[],navigationItems:[],navigationStates:[]});let b=[((e,a)=>{if(!e.presets)return c();let t="object"==typeof e.presets?e.presets:void 0,n=t?.categoryNavigationState??"PresetCategories",r=t?.presetNavigationState??"Presets",o={categoryNavigationState:n,presetNavigationState:r},s=[...p({typeOrAliases:["Admin","PresetCategory"],instanceName:"categoryList",componentName:"navigationPage",filters:m(n,"[self.id]"),readFactory:"createAdminPresetCategoryPageRead",readParams:y(o)},a),l({typeOrAlias:"PresetCategory",instanceName:"categorySidebar",componentName:"adminSidebar",filters:m(n,"[self.id]"),readFactory:"createAdminPresetCategorySidebarRead",readParams:y()},a),l({typeOrAlias:"PresetCategory",instanceName:"categoryDetail",componentName:"navigationPage",filters:m(r,"[self.id, ...self.$presets.map(c => c.id)]"),readFactory:"createAdminPresetListPageRead",readParams:y(o)},a),l({typeOrAlias:"Preset",instanceName:"presetSidebar",componentName:"adminSidebar",filters:m(r,"[self.id]"),readFactory:"createAdminPresetSidebarRead",readParams:y()},a),l({typeOrAlias:"Preset",instanceName:"category",componentName:"attributeSelection",readFactory:"createAdminPresetCategorySelectionRead",readParams:y(),writeFactory:"createAdminPresetCategorySelectionWrite",writeParams:y(),filters:i({items:[]})},a)].filter(d);if(!a.parsingContext.hasErrors)return{components:s,navigationItems:[{label:"Presets",icon:"FolderStarBold",navigationStates:[n,r]}],navigationStates:[n,r]}})(n.pages,r),((e,a)=>{if(!e.recipes||0===e.recipes.length)return c();let t=e.recipes.map(e=>{let t=e.navigationState??`${e.name}Recipes`,i={name:e.name,navigationState:t};return{components:[...p({typeOrAliases:["Admin","Recipe"],instanceName:`${e.name}Recipes`,componentName:"navigationPage",filters:m(t,"[self.id]"),readFactory:"createAdminRecipeCollectionPageRead",readParams:y(i)},a),l({typeOrAlias:"Recipe",instanceName:`${e.name}recipeSidebar`,componentName:"adminSidebar",filters:m(t,"[self.id]"),readFactory:"createAdminRecipeSidebarRead",readParams:y()},a)].filter(d),navigationItems:[],navigationStates:[t]}});if(!a.parsingContext.hasErrors)return{components:t.flatMap(e=>e.components),navigationItems:[{label:"Recipes",icon:"FireBold",items:e.recipes.map(e=>({label:e.name,navigationStates:[e.navigationState??`${e.name}Recipes`]}))}],navigationStates:t.flatMap(e=>e.navigationStates)}})(n.pages,r),((e,a,t)=>{let i=(e.pages??[]).map(e=>{let i,n,r=e.navigationState??e.key;return{components:[l({typeOrAlias:"Admin",instanceName:e.key,componentName:"navigationPage",filters:s(r),readFactory:"createAdminCustomPageRead",readParams:y((n=void 0===e.connectedDataEntry||void 0===t?void 0:(i=e.connectedDataEntry,Object.values(t.dataEntries).find(e=>e.key===i)),g([["key",e.key],["title",e.title],["navigationState",e.navigationState??e.key],["component",e.component],["actionsComponent",e.actionsComponent],["connectedDataEntry",e.connectedDataEntry],["connectedDataTitle",n?.title],["connectedDataDefinition",void 0===n?void 0:A(n.definition)],["connectedDataValues",v(n?.values)]])))},a),void 0===e.sidebar?void 0:l({typeOrAlias:e.entity??"Admin",instanceName:`${e.key}Sidebar`,componentName:"adminSidebar",filters:m(r,"[self.id]"),readFactory:"createAdminCustomSidebarRead",readParams:y(e.sidebar)},a)].filter(d),navigationItems:[{label:e.title,icon:e.icon,navigationStates:[r]}],navigationStates:[r]}});if(!a.parsingContext.hasErrors)return{components:i.flatMap(e=>e.components),navigationItems:i.flatMap(e=>e.navigationItems),navigationStates:i.flatMap(e=>e.navigationStates)}})(n.pages,r,o),((e,i,n)=>{if(!n)return c();for(let r of e.pages??[])void 0!==r.connectedDataEntry&&N(n,r.connectedDataEntry)&&i.parsingContext.error(a.ADMIN_PAGE_DATA_ENTRY_CONFLICT,t.ADMIN_PAGE_DATA_ENTRY_CONFLICT(r.key,r.connectedDataEntry));if(i.parsingContext.hasErrors)return;let r=new Set((e.pages??[]).map(e=>e.connectedDataEntry)),o=n.adminDataPages.filter(e=>"manual"!==e.kind||!r.has(e.key)).map(e=>((e,a)=>{let t="connected"!==e.kind,i=l({typeOrAlias:"Admin",instanceName:`${e.kind}${e.key}`,componentName:"navigationPage",filters:s(e.key),readFactory:"createAdminDataPageRead",readParams:y(S(e.key,e.title,t,e.icon,e.values,e.definition))},a),n=t?l({typeOrAlias:"DataTable",instanceName:`dataTable${e.key}Sidebar`,componentName:"adminSidebar",filters:m(e.key,"[self.id]"),readFactory:"createAdminDataTableSidebarRead",readParams:y(S(e.key,e.title,t,e.icon,e.values,e.definition))},a):void 0;if(!a.parsingContext.hasErrors)return{components:[i,n].filter(d),navigationItems:[{label:e.title,icon:e.icon??(t?"ListBullets":"CloudArrowUp"),navigationStates:[e.key]}],navigationStates:[e.key]}})(e,i));if(i.parsingContext.hasErrors||o.some(e=>void 0===e))return;let p=o.filter(d);return{components:p.flatMap(e=>e.components),navigationItems:p.flatMap(e=>e.navigationItems),navigationStates:p.flatMap(e=>e.navigationStates)}})(n.pages,r,o)];if(r.parsingContext.hasErrors||b.some(e=>void 0===e))return;let u=b.filter(d),C=u.flatMap(e=>e.navigationItems),k=u.flatMap(e=>e.navigationStates),E=l({typeOrAlias:"Admin",instanceName:"main",componentName:"navigationPanelList",readFactory:"createAdminNavigationPanelRead",readParams:y({items:C.map(P)}),filters:i({items:[]})},r),O=[...u.flatMap(e=>e.components),...[E].filter(d)];if(!r.parsingContext.hasErrors)return e({spec:n.pages,components:O,navigationItems:C,navigationStates:k})};

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

@@ -0,0 +1,44 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { EvalExpressionParser, ParseContext, PhoenixDefinitions } from '../../../../core/index.js';
+import type { CategorizedFile } from '../../../categorize/index.js';
+import type { MergedAdminPages, MergedAdminStates, MergedComponents, MergedDefaults, MergedExpressions, MergedInvariants, MergedModel, MergedPresets, MergedRelations } from '../../../merge/index.js';
+import { Components } from '../../components/index.js';
+import { Expressions } from '../../expressions/index.js';
+import { Invariants } from '../../invariants/index.js';
+import { ConfigurationSchema, Defaults, ModelVersion, Presets } from '../../model/index.js';
+import type { DataSpec } from '../../sections/index.js';
+import { ResolvedVersions } from '../resolved-versions.js';
+import { AdminPages } from './admin-pages.js';
+import { AdminStates } from './states.js';
+export type AdminSpec = Branded<'AdminSpec', {
+    readonly latestModel: ModelVersion;
+    readonly schemaVersion: number;
+    readonly resolvedVersions: ResolvedVersions;
+    readonly components: Components;
+    readonly configurationSchema: ConfigurationSchema;
+    readonly presets: Presets;
+    readonly expressions: Expressions;
+    readonly invariants: Invariants;
+    readonly defaults: Defaults;
+    readonly states: AdminStates;
+    readonly adminPages: AdminPages;
+}>;
+interface AdminSpecProps {
+    readonly rawModel: MergedModel;
+    readonly rawPresets: MergedPresets;
+    readonly rawExpressions: MergedExpressions;
+    readonly rawInvariants: MergedInvariants;
+    readonly rawRelations: MergedRelations;
+    readonly rawDefaults: MergedDefaults;
+    readonly migrationFiles: readonly CategorizedFile[];
+    readonly rawComponents: MergedComponents;
+    readonly rawAdminPages: MergedAdminPages;
+    readonly rawStates: MergedAdminStates;
+    readonly dataSpec: DataSpec;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly evalExpressionParser: EvalExpressionParser;
+    readonly label: string;
+    readonly requireMigrationFiles: boolean;
+}
+export declare const AdminSpec: (props: AdminSpecProps, ctx: ParseContext) => AdminSpec | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/application/admin-spec/admin-spec.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as s}from"../../../../errors/index.js";import{Components as n,UserComponents as r}from"../../components/index.js";import{Expressions as o}from"../../expressions/index.js";import{Invariants as i}from"../../invariants/index.js";import{ConfigurationSchema as a,Defaults as m,ModelVersion as l,Presets as p}from"../../model/index.js";import{Relations as d}from"../../relations/index.js";import{ResolvedVersions as f}from"../resolved-versions.js";import{AdminPages as S}from"./admin-pages.js";import{AdminStates as v}from"./states.js";export const AdminSpec=(g,x)=>{let{rawModel:u,rawPresets:I,rawExpressions:N,rawInvariants:T,rawRelations:_,rawDefaults:c,migrationFiles:j,rawComponents:A,rawAdminPages:C,dataSpec:E,phxDefinitions:M,evalExpressionParser:h,label:L,requireMigrationFiles:y}=g;if(0===Object.keys(u).length)return void x.at(L).error(t.MISSING_MODEL,s.MISSING_MODEL(L));u.latest||x.at(L).error(t.MISSING_LATEST,s.MISSING_LATEST(L));let G=new Map;for(let[e,t]of Object.entries(u)){let s=l(e,t,M,x.at(L,e));s&&G.set(s.versionKey,s)}if(x.hasErrors)return;let O=f(G,j,x,{requireMigrationFiles:y});if(!O)return;let D=O.versionedModels.find(e=>e.isLatest)?.modelVersion;if(!D)return;let V=O.latestVersion,P=a(D,V),b=d(_,D,x),w=i({rawInvariants:T,rawExpressions:N,rawRelations:_,rawComponents:A},D,x),F=p(I,D,b,x),k=S(C,{latestModel:D,parsingContext:x.at(L,"$adminPages")},E);if(!k)return;let K=r(A,{allNames:D.allNames,resolvedShapes:D.resolvedShapes,parsingContext:x}),$=m(c,D,x.at(L,"defaults")),q=o({rawExpressions:N,inferredExpressions:[...b.expressions,...w.expressions,...K.expressions]},{latestModel:D,aliases:D.aliases,entityTypes:D.entityTypes,evalExpressionParser:h,parsingContext:x}),z=n({userComponents:K.components,generatedComponents:[...b.components,...k.components],invariantComponents:w.components},{aliases:D.aliases,parsingContext:x});if(void 0!==$&&void 0!==q&&void 0!==z)return e({latestModel:D,schemaVersion:V,resolvedVersions:O,components:z,configurationSchema:P,presets:F,expressions:q,invariants:w,defaults:$,states:v(((n,r,o)=>{if(0===r.length)return n;let i=1===n.navigationStates.length&&"Default"===n.navigationStates[0]?[]:n.navigationStates,a=i.filter(e=>r.includes(e));return a.length>0&&o.error(t.ADMIN_PAGES_NAV_STATE_CONFLICT,s.ADMIN_PAGES_NAV_STATE_CONFLICT(a)),e({...n,navigationStates:[...i,...r]})})(g.rawStates,k.navigationStates,x),x),adminPages:k})};

package/dist/application-spec/parse-application-files/spec/application/admin-spec/index.d.ts

@@ -0,0 +1,3 @@
+export * from './admin-pages.js';
+export * from './admin-spec.js';
+export * from './states.js';

package/dist/application-spec/parse-application-files/spec/application/admin-spec/index.js

@@ -0,0 +1 @@
+export*from"./admin-pages.js";export*from"./admin-spec.js";export*from"./states.js";

package/dist/application-spec/parse-application-files/spec/application/admin-spec/states.d.ts

@@ -0,0 +1,8 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+import type { MergedAdminStates } from '../../../merge/index.js';
+import { type StateValue } from '../../sections/state-value.js';
+export type AdminStates = Branded<'AdminStates', {
+    readonly navigationStates: readonly StateValue[];
+}>;
+export declare const AdminStates: (merged: MergedAdminStates, ctx: ParseContext) => AdminStates;

package/dist/application-spec/parse-application-files/spec/application/admin-spec/states.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{DiagnosticCode as a,diagnosticMessages as e}from"../../../../errors/index.js";import{StateValue as o}from"../../sections/state-value.js";export const AdminStates=(s,r)=>t({navigationStates:((t,s,r)=>{let i=[],n=new Set;for(let m of s){n.has(m)&&r.error(a.DUPLICATE_STATE_VALUE,e.DUPLICATE_STATE_VALUE(t,m)),n.add(m);let s=o(m,t,r);s&&i.push(s)}return i})("navigationStates",s.navigationStates,r)});

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

@@ -0,0 +1,30 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EvalExpressionParser, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { CategorizedFile } from '../../categorize/index.js';
+import type { MergedSpec } from '../../merge/index.js';
+import { AppMetadata, BundleSizeBudgets, DataSpec, Infra } from '../sections/index.js';
+import { AdminSpec } from './admin-spec/index.js';
+import { ConfiguratorSpec } from './configurator-spec/index.js';
+/** The validated, cross-referenced application specification — main output of the parse pipeline. */
+export type ApplicationSpec = Branded<'ApplicationSpec', {
+    readonly configurator: ConfiguratorSpec;
+    readonly admin: AdminSpec;
+    readonly appMetadata: AppMetadata;
+    readonly infra: Infra;
+    readonly budgets: BundleSizeBudgets;
+    readonly dataSpec: DataSpec;
+}>;
+interface ApplicationSpecProps {
+    readonly merged: MergedSpec;
+    readonly migrationFiles: readonly CategorizedFile[];
+    readonly adminMigrationFiles: readonly CategorizedFile[];
+    readonly transformerFiles: readonly string[];
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly evalExpressionParser: EvalExpressionParser;
+}
+/**
+ * Builds the full ApplicationSpec from merged configurator and admin models.
+ * Configurator and admin use separate constructors so their parsing can diverge.
+ */
+export declare const ApplicationSpec: (props: ApplicationSpecProps, ctx: ParseContext) => ApplicationSpec | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/application/application-spec.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{AppMetadata as s,BundleSizeBudgets as a,DataSpec as t,Infra as n}from"../sections/index.js";import{AdminSpec as r}from"./admin-spec/index.js";import{ConfiguratorSpec as o}from"./configurator-spec/index.js";export const ApplicationSpec=(i,l)=>{let{merged:m,migrationFiles:p,adminMigrationFiles:d,transformerFiles:c,phxDefinitions:u,evalExpressionParser:w}=i,f=s(m.appMetadata,l);if(!f)return;let S=t({mergedDataSpec:m.dataSpec,mergedChunks:m.chunks},l);if(!S||l.hasErrors)return;let g=l.startSpan("ConfiguratorSpec","ApplicationSpec"),h=o({rawModel:m.model,rawPresets:m.presets,rawExpressions:m.expressions,rawInvariants:m.invariants,rawRelations:m.relations,rawDefaults:m.defaults,dataSchemas:m.dataSchemas,dataSpec:S,appMetadata:f,rawTheme:m.theme,rawUi:m.ui,rawTransformers:m.transformers,rawAssistant:m.assistant,migrationFiles:p,transformerFiles:c,rawComponents:m.components,rawStates:m.configuratorStates,phxDefinitions:u,evalExpressionParser:w,label:"model"},l);if(g(),!h)return;let M=l.startSpan("AdminSpec","ApplicationSpec"),x=r({rawModel:m.adminModel,rawPresets:m.adminPresets,rawExpressions:m.adminExpressions,rawInvariants:m.adminInvariants,rawRelations:m.adminRelations,rawDefaults:m.adminDefaults,migrationFiles:d,rawComponents:m.adminComponents,rawAdminPages:m.adminPages,rawStates:m.adminStates,dataSpec:S,phxDefinitions:u,evalExpressionParser:w,label:"adminModel",requireMigrationFiles:!0},l);if(M(),!x)return;let v=n(m.infra,l);if(!v)return;let y=a(m.budgets);return l.count("entityTypes",h.latestModel.entityTypes.length),l.count("aliases",h.latestModel.aliases.size),l.count("commonTypes",h.latestModel.commonTypes.size),l.count("shapes",h.latestModel.shapes.size),l.count("components",h.components.length),l.count("modelVersions",h.resolvedVersions.versionedModels.length),l.count("presets",h.presets.presets.length),e({configurator:h,admin:x,appMetadata:f,infra:v,budgets:y,dataSpec:S})};

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

@@ -0,0 +1,53 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EvalExpressionParser, type ParseContext, type PhoenixDefinitions } from '../../../../core/index.js';
+import type { CategorizedFile } from '../../../categorize/index.js';
+import type { MergedAssistant, MergedComponents, MergedConfiguratorStates, MergedDataSchemas, MergedDefaults, MergedExpressions, MergedInvariants, MergedModel, MergedPresets, MergedRelations, MergedTheme, MergedTransformers, MergedUi } from '../../../merge/index.js';
+import { Components } from '../../components/index.js';
+import { Expressions } from '../../expressions/index.js';
+import { Invariants } from '../../invariants/index.js';
+import { ConfigurationSchema, DataSchemas, Defaults, ModelVersion, Presets } from '../../model/index.js';
+import { type AppMetadata, AssistantServerSettings, AssistantSpec, type DataSpec, Theme, Transformers, Ui } from '../../sections/index.js';
+import { ResolvedVersions } from '../resolved-versions.js';
+import { ConfiguratorStates } from './states.js';
+export type ConfiguratorSpec = Branded<'ConfiguratorSpec', {
+    readonly latestModel: ModelVersion;
+    readonly schemaVersion: number;
+    readonly resolvedVersions: ResolvedVersions;
+    readonly components: Components;
+    readonly configurationSchema: ConfigurationSchema;
+    readonly presets: Presets;
+    readonly expressions: Expressions;
+    readonly invariants: Invariants;
+    readonly dataSchemas: DataSchemas;
+    readonly defaults: Defaults;
+    readonly states: ConfiguratorStates;
+    readonly theme: Theme;
+    readonly ui: Ui;
+    readonly transformers: Transformers;
+    readonly assistant: AssistantSpec;
+    readonly assistantServerSettings: AssistantServerSettings;
+}>;
+interface ConfiguratorSpecProps {
+    readonly rawModel: MergedModel;
+    readonly rawPresets: MergedPresets;
+    readonly rawExpressions: MergedExpressions;
+    readonly rawInvariants: MergedInvariants;
+    readonly rawRelations: MergedRelations;
+    readonly rawDefaults: MergedDefaults;
+    readonly dataSchemas: MergedDataSchemas;
+    readonly dataSpec: DataSpec;
+    readonly appMetadata: AppMetadata;
+    readonly rawTheme: MergedTheme;
+    readonly rawUi: MergedUi;
+    readonly rawTransformers: MergedTransformers;
+    readonly rawAssistant: MergedAssistant;
+    readonly migrationFiles: readonly CategorizedFile[];
+    readonly transformerFiles: readonly string[];
+    readonly rawComponents: MergedComponents;
+    readonly rawStates: MergedConfiguratorStates;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly evalExpressionParser: EvalExpressionParser;
+    readonly label: string;
+}
+export declare const ConfiguratorSpec: (props: ConfiguratorSpecProps, ctx: ParseContext) => ConfiguratorSpec | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/application/configurator-spec/configurator-spec.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as s,diagnosticMessages as t}from"../../../../errors/index.js";import{Components as r,UserComponents as o}from"../../components/index.js";import{Expressions as i}from"../../expressions/index.js";import{Invariants as n}from"../../invariants/index.js";import{ConfigurationSchema as a,DataSchemas as m,Defaults as p,ModelVersion as l,Presets as d}from"../../model/index.js";import{Relations as f}from"../../relations/index.js";import{AssistantServerSettings as x,AssistantSpec as S,Theme as v,Transformers as c,Ui as j}from"../../sections/index.js";import{ResolvedVersions as u}from"../resolved-versions.js";import{ConfiguratorStates as g}from"./states.js";export const ConfiguratorSpec=(C,I)=>{let{rawModel:M,rawPresets:h,rawExpressions:y,rawInvariants:E,rawRelations:N,rawDefaults:T,dataSchemas:L,dataSpec:G,appMetadata:O,rawTheme:_,rawUi:b,rawTransformers:w,rawAssistant:A,migrationFiles:D,transformerFiles:V,rawComponents:k,phxDefinitions:K,evalExpressionParser:q,label:z}=C;if(0===Object.keys(M).length)return void I.at(z).error(s.MISSING_MODEL,t.MISSING_MODEL(z));M.latest||I.at(z).error(s.MISSING_LATEST,t.MISSING_LATEST(z));let B=new Map;for(let[e,s]of Object.entries(M)){let t=l(e,s,K,I.at(z,e));t&&B.set(t.versionKey,t)}if(I.hasErrors)return;let F=u(B,D,I);if(!F)return;let H=F.versionedModels.find(e=>e.isLatest)?.modelVersion;if(!H)return;let J=F.latestVersion,P=a(H,J),Q=f(N,H,I),R=n({rawInvariants:E,rawExpressions:y,rawRelations:N,rawComponents:k},H,I),U=d(h,H,Q,I),W=o(k,{allNames:H.allNames,resolvedShapes:H.resolvedShapes,parsingContext:I}),X=p(T,H,I.at(z,"defaults")),Y=c(w,V,I),Z=i({rawExpressions:y,inferredExpressions:[...Q.expressions,...R.expressions,...W.expressions]},{latestModel:H,aliases:H.aliases,entityTypes:H.entityTypes,evalExpressionParser:q,parsingContext:I}),$=r({userComponents:W.components,generatedComponents:Q.components,invariantComponents:R.components},{aliases:H.aliases,parsingContext:I}),ee=m({merged:L,dataSpec:G,appMetadata:O,phxDefinitions:K,parsingContext:I}),es=g(C.rawStates,I.at("states"));if(void 0!==X&&void 0!==Z&&void 0!==$&&void 0!==ee)return e({latestModel:H,schemaVersion:J,dataSchemas:ee,resolvedVersions:F,components:$,configurationSchema:P,presets:U,expressions:Z,invariants:R,defaults:X,states:es,theme:v(_),ui:j(b),transformers:Y,assistant:S(A,{model:H,states:es,phxDefinitions:K,expressions:Z,components:$},I),assistantServerSettings:x(A)})};

package/dist/application-spec/parse-application-files/spec/application/configurator-spec/index.d.ts

@@ -0,0 +1,2 @@
+export * from './configurator-spec.js';
+export * from './states.js';

package/dist/application-spec/parse-application-files/spec/application/configurator-spec/index.js

@@ -0,0 +1 @@
+export*from"./configurator-spec.js";export*from"./states.js";

package/dist/application-spec/parse-application-files/spec/application/configurator-spec/states.d.ts

@@ -0,0 +1,11 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+import type { MergedConfiguratorStates } from '../../../merge/index.js';
+import { StateValue } from '../../sections/state-value.js';
+export type ConfiguratorStates = Branded<'ConfiguratorStates', {
+    readonly navigationStates: readonly StateValue[];
+    readonly viewStates: readonly StateValue[];
+    readonly toolStates: readonly StateValue[];
+    readonly exportStates: readonly StateValue[];
+}>;
+export declare const ConfiguratorStates: (merged: MergedConfiguratorStates, ctx: ParseContext) => ConfiguratorStates;

package/dist/application-spec/parse-application-files/spec/application/configurator-spec/states.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{DiagnosticCode as e,diagnosticMessages as o}from"../../../../errors/index.js";import{StateValue as a}from"../../sections/state-value.js";let r=(t,r,s)=>{let i=[],S=new Set;for(let n of r){S.has(n)&&s.error(e.DUPLICATE_STATE_VALUE,o.DUPLICATE_STATE_VALUE(t,n)),S.add(n);let r=a(n,t,s);r&&i.push(r)}return i};export const ConfiguratorStates=(e,o)=>{let a=r("navigationStates",e.navigationStates,o),s=r("viewStates",e.viewStates,o);return t({navigationStates:a,viewStates:s,toolStates:r("toolStates",e.toolStates,o),exportStates:r("exportStates",e.exportStates,o)})};

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

@@ -0,0 +1,4 @@
+export * from './admin-spec/index.js';
+export * from './application-spec.js';
+export * from './configurator-spec/index.js';
+export * from './resolved-versions.js';

package/dist/application-spec/parse-application-files/spec/application/index.js

@@ -0,0 +1 @@
+export*from"./admin-spec/index.js";export*from"./application-spec.js";export*from"./configurator-spec/index.js";export*from"./resolved-versions.js";

package/dist/application-spec/parse-application-files/spec/application/resolved-versions.d.ts

@@ -0,0 +1,43 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+import type { CategorizedFile } from '../../categorize/index.js';
+import type { ModelVersion, ModelVersionKey } from '../model/index.js';
+/**
+ * A single resolved model version ready for codegen.
+ * `version` is the integer version number (1, 2, 3, …).
+ * `key` is always 'v{N}' — never 'latest'.
+ * `isLatest` marks the version that corresponds to the 'latest' model key.
+ * `migrationFile` is the relative path to the migration file (present for v2+).
+ */
+export interface ResolvedModelVersion {
+    readonly version: number;
+    readonly key: string;
+    readonly isLatest: boolean;
+    readonly modelVersion: ModelVersion;
+    readonly migrationFile: string | undefined;
+}
+/**
+ * Full version resolution result.
+ * `latestVersion` is the integer assigned to the 'latest' key (max(numeric versions) + 1).
+ * `versionedModels` is sorted ascending by version number.
+ */
+export type ResolvedVersions = Branded<'ResolvedVersions', {
+    readonly versionedModels: readonly ResolvedModelVersion[];
+    readonly latestVersion: number;
+}>;
+interface ResolveVersionsOptions {
+    readonly requireMigrationFiles: boolean;
+}
+/**
+ * Validates version contiguity, migration file presence, and builds the resolved version list.
+ *
+ * Model versions must form a contiguous sequence: v1, v2, …, vN, latest (no gaps).
+ * Every version from v2 onward must have a corresponding migration file unless the caller owns
+ * migrations outside the application-spec file convention, as the built-in common-admin domain does.
+ * No migration files may exist for versions outside the model range.
+ *
+ * Emits errors via ParseContext — does NOT check for 'latest' key presence
+ * (that is already validated by ApplicationSpec before calling this factory).
+ */
+export declare const ResolvedVersions: (model: ReadonlyMap<ModelVersionKey, ModelVersion>, migrationFiles: readonly CategorizedFile[], ctx: ParseContext, options?: ResolveVersionsOptions) => ResolvedVersions | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/application/resolved-versions.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../errors/index.js";let o=/v(\d+)\.ts$/,s=e=>{let r=e.match(o);return r?parseInt(r[1],10):void 0};export const ResolvedVersions=(o,i,l,I={requireMigrationFiles:!0})=>{let a=new Map;for(let[e,r]of o)a.set(String(e),r);let n=[];for(let e of a.keys())"latest"!==e&&n.push(parseInt(e.replace("v",""),10));let N=Math.max(...n,0)+1;for(let e=1;e<N;e++)n.includes(e)||l.error(r.MISSING_VERSION,t.MISSING_VERSION(e));if(l.hasErrors)return;let f=new Map;for(let e of i){let r=s(e.file.name);void 0!==r&&f.set(r,e.file.name)}if(I.requireMigrationFiles)for(let e=2;e<=N;e++)f.has(e)||l.error(r.MISSING_MIGRATION,t.MISSING_MIGRATION(e));for(let[e,o]of f)e<2&&l.error(r.MIGRATION_INVALID_START,t.MIGRATION_INVALID_START(o)),e>N&&l.error(r.UNKNOWN_MIGRATION,t.UNKNOWN_MIGRATION(o,e,N));if(!l.hasErrors)return e({versionedModels:[...n,N].sort((e,r)=>e-r).map(e=>{let r=e===N,t=r?"latest":`v${e}`;return{version:e,key:`v${e}`,isLatest:r,modelVersion:a.get(t),migrationFile:f.get(e)}}),latestVersion:N})};

package/dist/application-spec/parse-application-files/spec/common/index.d.ts

@@ -0,0 +1 @@
+export * from './validate-schema-refs.js';

package/dist/application-spec/parse-application-files/spec/common/index.js

@@ -0,0 +1 @@
+export*from"./validate-schema-refs.js";

package/dist/application-spec/parse-application-files/spec/common/validate-schema-refs.d.ts

@@ -0,0 +1,9 @@
+import { type ParseContext, type PhoenixDefinitions, type SchemaRef } from '../../../core/index.js';
+/**
+ * Validates $ref targets in shape and commonType schemas.
+ * Allowed patterns:
+ * - `#/model/{versionKey}/commonTypes/{name}` — internal ref, must match current version and exist
+ * - `https://salsita.ai/phoenix/schemas/types.json#/definitions/{name}` — phoenix def, must exist
+ * - `phx:{name}` — short alias for the above
+ */
+export declare const validateSchemaRefs: (refs: readonly SchemaRef[], versionKey: string, commonTypeNames: ReadonlySet<string>, phxDefinitions: PhoenixDefinitions, ctx: ParseContext) => void;

package/dist/application-spec/parse-application-files/spec/common/validate-schema-refs.js

@@ -0,0 +1 @@
+import{COMMON_SHORT_PREFIX as e,INTERNAL_REF_PATTERN as r,extractPhxDefName as t}from"../../../core/index.js";import{DiagnosticCode as N,diagnosticMessages as o}from"../../../errors/index.js";export const validateSchemaRefs=(a,i,n,l,_)=>{for(let s of a){let a=_.at(...s.path),u=t(s.value);if(void 0!==u){u in l||a.error(N.UNKNOWN_PHX_DEFINITION,o.UNKNOWN_PHX_DEFINITION(s.value,u));continue}if(s.value.startsWith(e)){let r=s.value.slice(e.length);n.has(r)||a.error(N.UNKNOWN_COMMON_TYPE_REF,o.UNKNOWN_COMMON_TYPE_REF(s.value,r));continue}let O=r.exec(s.value);if(O){let[,e,r]=O;if(e!==i){a.error(N.INVALID_REF,`$ref "${s.value}" references version "${e}" but the current version is "${i}". Internal refs must target the same version they are declared in.`);continue}n.has(r)||a.error(N.UNKNOWN_COMMON_TYPE_REF,o.UNKNOWN_COMMON_TYPE_REF(s.value,r));continue}a.error(N.INVALID_REF,o.INVALID_REF(s.value))}};

package/dist/application-spec/parse-application-files/spec/components/bindings/index.d.ts

@@ -0,0 +1,2 @@
+export * from './read-binding.js';
+export * from './write-binding.js';

package/dist/application-spec/parse-application-files/spec/components/bindings/index.js

@@ -0,0 +1 @@
+export*from"./read-binding.js";export*from"./write-binding.js";