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

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-files.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generates a standalone domain module from an application-spec domain slot.
+ *
+ * The output contains only importable model artifacts and has no phx binding, project scaffolding,
+ * authored implementation files, or runtime bootstrap code.
+ *
+ * @module
+ */
+import { GeneratedApplicationFile } from '../../../core/index.js';
+import type { PhoenixDefinitions } from '../../../core/index.js';
+import type { CommonAdminSpec, ResolvedVersions } from '../../../parse-application-files/index.js';
+import { type StandaloneDomainImportPaths } from './standalone-domain-version.js';
+import { type StandaloneEnhancedModelImportPaths } from './standalone-enhanced-model.js';
+/** Inputs required to emit standalone versioned model modules. */
+export interface GenerateStandaloneDomainFilesOptions {
+    readonly importPaths: StandaloneDomainImportPaths;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly resolvedVersions: ResolvedVersions;
+}
+/** Inputs required to emit the complete minimal common-admin module. */
+export interface GenerateStandaloneCommonAdminFilesOptions {
+    readonly enhancedModelImportPaths: StandaloneEnhancedModelImportPaths;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly spec: CommonAdminSpec;
+    readonly versionImportPaths: StandaloneDomainImportPaths;
+}
+/** Emits the versioned model modules and the barrel re-exporting the latest version. */
+export declare const generateStandaloneDomainFiles: (options: GenerateStandaloneDomainFilesOptions) => readonly GeneratedApplicationFile[];
+/** Emits the minimal model, enhanced-model, data-schema, and state artifacts consumed by common-admin. */
+export declare const generateStandaloneCommonAdminFiles: (options: GenerateStandaloneCommonAdminFilesOptions) => readonly GeneratedApplicationFile[];

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-files.js

@@ -0,0 +1 @@
+import{GeneratedApplicationFile as e}from"../../../core/index.js";import{generateStandaloneApplicationTypes as o}from"./standalone-application-types.js";import{generateStandaloneDomainModelIndex as n}from"./standalone-domain-model-index.js";import{generateStandaloneDomainVersion as t}from"./standalone-domain-version.js";import{generateStandaloneEnhancedModel as s}from"./standalone-enhanced-model.js";export const generateStandaloneDomainFiles=o=>{let{importPaths:s,phxDefinitions:a,resolvedVersions:i}=o;return[...i.versionedModels.map(o=>e(`model/versions/v${o.version}.ts`,t({importPaths:s,phxDefinitions:a,version:o,latest:o.version===i.latestVersion}))),e("model/index.ts",n(i))]};export const generateStandaloneCommonAdminFiles=n=>{let{enhancedModelImportPaths:t,phxDefinitions:a,spec:i,versionImportPaths:r}=n;return[...generateStandaloneDomainFiles({importPaths:r,phxDefinitions:a,resolvedVersions:i.admin.resolvedVersions}),e("enhanced-model.ts",s({adminSpec:i.admin,importPaths:t,phxDefinitions:a})),e("application-types.ts",o({phxDefinitions:a,spec:i}))]};

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-model-index.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedVersions } from '../../../parse-application-files/index.js';
+/** Generates the standalone domain model barrel re-exporting the latest version's surface. */
+export declare const generateStandaloneDomainModelIndex: (resolvedVersions: ResolvedVersions) => string;

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-model-index.js

@@ -0,0 +1,3 @@
+import{autoHeader as e}from"../common/file-headers.js";export const generateStandaloneDomainModelIndex=o=>`${e("model/index.ts","Standalone domain model barrel.")}
+export * from './versions/v${o.latestVersion}.js'
+`;

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-version.d.ts

@@ -0,0 +1,28 @@
+import type { PhoenixDefinitions } from '../../../core/index.js';
+import type { ResolvedModelVersion } from '../../../parse-application-files/index.js';
+/** Import paths used by a standalone domain module emitted outside a generated project. */
+export interface StandaloneDomainImportPaths {
+    readonly model: string;
+    readonly reflection: string;
+}
+interface GenerateStandaloneDomainVersionOptions {
+    readonly importPaths: StandaloneDomainImportPaths;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly version: ResolvedModelVersion;
+    /**
+     * Whether this version is the latest model. Only the latest version carries runtime
+     * reflections — historical versions exist to type the hand-written migration chain and expose
+     * their entity-type names, so they are emitted (near) type-only.
+     */
+    readonly latest: boolean;
+}
+/**
+ * Generates one versioned domain model module.
+ *
+ * The latest version emits entity types plus runtime `DomainEntityReflection`/`RawAliasReflection`
+ * constants and the `aliases` map consumed by the common-admin barrel. Historical versions emit
+ * the entity/alias types and a lightweight `AnyDomainEntity.types` name list — the only runtime
+ * value the migration chain reads — without the per-entity schema payloads.
+ */
+export declare const generateStandaloneDomainVersion: (options: GenerateStandaloneDomainVersionOptions) => string;
+export {};

package/dist/application-spec/generate-application/code/common-admin/standalone-domain-version.js

@@ -0,0 +1,21 @@
+import{PhoenixDefinitionEntry as n,PhoenixDefinitions as e}from"../../../core/index.js";import{autoHeader as t}from"../common/file-headers.js";import{CodeImports as i,exportTypeDeclarations as o,stripConsistentTypeDefinitionsDisable as r}from"../common/index.js";import{generateModelTypeDecls as a}from"../templates/global-definition/index.js";export const generateStandaloneDomainVersion=s=>{let m,{importPaths:l,phxDefinitions:p,version:d,latest:y}=s,$=new i,c=d.modelVersion,f=void 0===(m=p.DomainEntityId)?p:e({...p,DomainEntityId:n({...m,import:void 0})});$.addTypeImport(l.model,"DomainEntityId");let S=r(o(a(c,f,$,0,!0))),g=c.entityTypes.map(String);if(!y)return`${t(`model/versions/v${d.version}.ts`,"Historical domain model types for the migration chain.")}
+${$.toString()}
+
+${S}
+export const AnyDomainEntity = {
+  types: [${g.map(n=>JSON.stringify(n)).join(", ")}] as const satisfies ReadonlyArray<AnyDomainEntity['type']>,
+}
+`;$.addImport(l.reflection,"DomainEntityReflection"),$.addImport(l.reflection,"RawAliasReflection");let v=c.entitySchemas.map(n=>{let e=JSON.stringify(n.shapeSchema,null,2);return`export const ${n.entityType}: DomainEntityReflection<${n.entityType}> = new DomainEntityReflection<${n.entityType}>('${n.entityType}', [${e}])`}),x=[...c.aliases],D=x.map(([n])=>String(n)),R=x.map(([n,e])=>{let t=e.map(String).join(", ");return`export const ${n}: RawAliasReflection<${n}> = new RawAliasReflection<${n}>('${n}', [${t}])`});return`${t(`model/versions/v${d.version}.ts`,"Standalone versioned domain model and reflections.")}
+${$.toString()}
+
+export const modelVersion = ${d.version}
+
+${S}
+${v.join("\n\n")}
+
+${R.join("\n\n")}
+
+export const aliases = {
+${D.map(n=>`  ${n}: ${n}.types,`).join("\n")}
+} as const
+`};

package/dist/application-spec/generate-application/code/common-admin/standalone-enhanced-model.d.ts

@@ -0,0 +1,21 @@
+import type { PhoenixDefinitions } from '../../../core/index.js';
+import type { AdminSpec } from '../../../parse-application-files/index.js';
+export interface StandaloneEnhancedModelImportPaths {
+    readonly model: string;
+    readonly domainModel: string;
+    readonly violation: string;
+}
+export interface GenerateStandaloneEnhancedModelOptions {
+    readonly adminSpec: AdminSpec;
+    readonly importPaths: StandaloneEnhancedModelImportPaths;
+    readonly phxDefinitions: PhoenixDefinitions;
+}
+/**
+ * Generates the expression-aware `$` entity types for the common admin.
+ *
+ * Type-only on purpose: the common admin never runs from this module (the real runtime is the
+ * admin domain merged into each generated application), so no `$` reflection constants are
+ * emitted — the types exist to spell the admin-interface generics and to type-check the
+ * hand-written implementation in `domain/admin-domain/implementation/`.
+ */
+export declare const generateStandaloneEnhancedModel: (options: GenerateStandaloneEnhancedModelOptions) => string;

package/dist/application-spec/generate-application/code/common-admin/standalone-enhanced-model.js

@@ -0,0 +1,7 @@
+import{autoHeader as e}from"../common/file-headers.js";import{CodeImports as o,exportTypeDeclarations as n,stripConsistentTypeDefinitionsDisable as t}from"../common/index.js";import{generateEntityExpressionComposites as m,generateExpressionTypeDecls as d}from"../templates/global-definition/index.js";export const generateStandaloneEnhancedModel=i=>{let{adminSpec:a,importPaths:l,phxDefinitions:r}=i,{expressions:p,latestModel:s}=a,c=new o;for(let e of s.entityTypes.map(String))c.addTypeImport(l.model,e);let f=d(p,r,c,0,!0,{Violation:l.violation}),g=t(m(s,p,c,0,"",l.domainModel));return`${e("enhanced-model.ts","Standalone common-admin enhanced model types.")}
+${c.toString()}
+
+${n(f)}
+
+${n(g)}
+`};

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

@@ -0,0 +1,104 @@
+/**
+ * Generates the application files that a running configurator imports.
+ *
+ * Membership criterion: a file belongs to this group when the configurator or admin runtime imports
+ * it in order to execute the parsed application domain — the domain model, its globals, and the
+ * code that binds authored project files into runtime sections. A file that only exists so a
+ * standalone application can boot, render, or deploy belongs to the standalone-application group,
+ * and a file that configures the generated project itself belongs to the project-scaffolding group.
+ *
+ * This is the group a host embedding an already-built runtime needs on its own, which is why it is
+ * callable without also generating a complete standalone application.
+ *
+ * How the generated files reach the `phx` API is this group's own decision, expressed as a
+ * `PhxBindingStrategy` the caller selects. The strategy is chosen once, here at the group boundary,
+ * rather than threaded as a mode flag through the individual templates: every template stays
+ * unaware of which binding is in effect and simply renders the blocks the strategy supplies.
+ *
+ * @module
+ */
+import { GeneratedApplicationFile } from '../../core/index.js';
+import type { PhoenixDefinitions } from '../../core/index.js';
+import type { ApplicationSpec, CategorizedFiles } from '../../parse-application-files/index.js';
+import type { StateConstantsGenerator } from './templates/index.js';
+/**
+ * Inputs required by the files imported into a running configurator.
+ *
+ * The parsed spec supplies the domain model, the categorized project files supply the authored
+ * implementation files each generated runtime section must import, and the phx definitions supply
+ * the ambient global declarations. Nothing about hosting, deployment, or project layout is needed
+ * here — that separation is what makes this group independently callable.
+ */
+export interface GenerateDomainRuntimeFilesOptions {
+    readonly applicationSpec: ApplicationSpec;
+    readonly categorizedFiles: CategorizedFiles;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly includeDefaultEnvs?: boolean;
+}
+/**
+ * Selects how generated domain-runtime files expose phx and where their application types live.
+ *
+ * The two supported bindings differ in whether generated code owns a global namespace. A generated
+ * project is the only thing running on its page, so it can assign `globalThis.phx` and declare its
+ * application types ambiently. A story-local build cannot: several independently generated
+ * applications may share one page, so each needs its own module-scoped `phx` values and its own
+ * importable type module.
+ *
+ * Both bindings are assembled from the same templates. A strategy only supplies the pieces that
+ * differ, which keeps the two outputs structurally identical everywhere the binding is irrelevant.
+ */
+export interface PhxBindingStrategy {
+    /**
+     * Module specifier the generated files import their application types from, or `undefined` when
+     * the types are ambient.
+     *
+     * `undefined` makes every application-type import registration a no-op, so generated files
+     * reference the types declared globally by `globals.d.ts` and render no import for them. A
+     * specifier instead collects each registered type name into a type-only import from that module.
+     */
+    readonly applicationTypeImportSource?: string;
+    /**
+     * Emits the file that declares the application's model, expression and state types.
+     *
+     * Global binding emits ambient `globals.d.ts` declarations; module binding emits an importable
+     * `application-types.ts`. Both render the same declarations from one shared generator, so the two
+     * files can never drift apart in what they describe — only in how they expose it.
+     */
+    readonly generateApplicationTypesFile: (applicationSpec: ApplicationSpec, phxDefinitions: PhoenixDefinitions) => GeneratedApplicationFile;
+    /**
+     * Emits the trailing block of `domain-spec.ts` that publishes the generated domain surface.
+     *
+     * Global binding assigns `globalThis.phx.domain` and `globalThis.phx.applicationTypes`; module
+     * binding exports the same two surfaces as `phxDomain` and `phxApplicationTypes` const values and
+     * assigns nothing.
+     */
+    readonly generateDomainBindingBlock: () => string;
+    /**
+     * Emits the state enum constants in `domain-spec.ts`.
+     *
+     * This differs per binding because the state names exist twice: as types on the application-type
+     * surface, and as `EnumLike` runtime values here. Global binding declares both locally, since the
+     * types are ambient. Module binding must import the types instead, so it registers them as
+     * application-type imports and emits values only — declaring a local type of the same name
+     * alongside the import is the TS2440 collision this split exists to avoid.
+     */
+    readonly generateStateConstants: StateConstantsGenerator;
+    /** Emits the binding block of `configurator-globals.ts`; empty when nothing is assigned. */
+    readonly generateConfiguratorBindingBlock: () => string;
+    /**
+     * Header description written into generated `configurator-globals.ts`.
+     *
+     * It is supplied alongside the block so the file never describes a global assignment a
+     * module-scoped binding does not make.
+     */
+    readonly configuratorBindingDescription: string;
+    /** Emits the binding block of `admin-globals.ts`; empty when nothing is assigned. */
+    readonly generateAdminBindingBlock: () => string;
+    /** Header description written into generated `admin-globals.ts`. See the configurator counterpart. */
+    readonly adminBindingDescription: string;
+}
+/** Existing project behavior: ambient declarations and globalThis phx assignments. */
+export declare const globalPhxBindingStrategy: PhxBindingStrategy;
+/** Story-local behavior: explicit type imports and module exports without globalThis assignments. */
+export declare const modulePhxBindingStrategy: PhxBindingStrategy;
+export declare const generateDomainRuntimeFiles: (options: GenerateDomainRuntimeFilesOptions, phxBindingStrategy: PhxBindingStrategy) => readonly GeneratedApplicationFile[];

package/dist/application-spec/generate-application/code/domain-runtime-files.js

@@ -0,0 +1 @@
+import{GeneratedApplicationFile as n}from"../../core/index.js";import{createApplicationTypeImportRegistrar as e}from"./common/index.js";import{generateAdminGlobalBindingBlock as i,generateApplicationSpecAdminCode as o,generateApplicationSpecAdminFrontendCode as t,generateApplicationSpecAdminGlobals as r,generateApplicationSpecConfiguratorCode as a,generateApplicationSpecConfiguratorConfig as s,generateApplicationSpecConfiguratorFrontendCode as d,generateApplicationSpecConfiguratorGlobals as c,generateApplicationSpecDomainFile as g,generateApplicationSpecDomainSpecFile as m,generateApplicationSpecGlobals as p,generateApplicationSpecTypesModule as l,generateConfiguratorGlobalBindingBlock as f,generateImportedStateConstants as B,generatePhxExportsBlock as u,generatePhxGlobalsBlock as x,generateStateConstants as h}from"./templates/index.js";import{splitWebhookMembership as k}from"./webhook-safe-files.js";let y=()=>"";export const globalPhxBindingStrategy={generateApplicationTypesFile:(e,i)=>n("globals.d.ts",p(e,i)),generateDomainBindingBlock:x,generateStateConstants:h,generateConfiguratorBindingBlock:f,configuratorBindingDescription:"Creates the configurator interface and sets phx.frontend — must run before any user code imports.",generateAdminBindingBlock:i,adminBindingDescription:"Creates the admin interface and sets phx.frontend.admin — must run before admin user code imports."};export const modulePhxBindingStrategy={applicationTypeImportSource:"./application-types.js",generateApplicationTypesFile:(e,i)=>n("application-types.ts",l(e,i)),generateDomainBindingBlock:u,generateStateConstants:B,generateConfiguratorBindingBlock:y,configuratorBindingDescription:"Creates and exports the configurator interface for a module-scoped phx binding.",generateAdminBindingBlock:y,adminBindingDescription:"Creates and exports the admin interface for a module-scoped phx binding."};let C=n=>n.map(n=>n.file.name);export const generateDomainRuntimeFiles=(i,p)=>{let{applicationSpec:l,categorizedFiles:f,phxDefinitions:B,includeDefaultEnvs:u}=i,x=e(p.applicationTypeImportSource),h=C(f.expressions),y=C(f.handlers),b=C(f.elements),D=C(f.transformers),S=C(f.invariants),A=C(f.adminInvariants),F=C(f.adminExpressions),j=C(f.adminElements),I=k(f.components),T=C(I.webhookIncluded),w=C(I.frontendOnly),v=k(f.adminComponents),E=C(v.webhookIncluded),O=C(v.frontendOnly);return[n("domain-spec.ts",m(l,{generateBindingBlock:p.generateDomainBindingBlock,generateStateConstants:p.generateStateConstants,registerApplicationTypeImports:x})),n("configurator-globals.ts",c(p.generateConfiguratorBindingBlock,p.configuratorBindingDescription)),n("configurator-domain-code.ts",a({expressionFiles:h,invariantFiles:S,componentFiles:T},x)),n("configurator-frontend-code.ts",d({transformerFiles:D,handlerFiles:y,elementFiles:b,componentFiles:w},x)),n("admin-domain-code.ts",o({adminExpressionFiles:F,adminInvariantFiles:A,adminComponentFiles:E},x)),n("admin-frontend-code.ts",t({adminElementFiles:j,adminComponentFiles:O},x)),n("domain.ts",g(l)),n("configurator-config.ts",s(l,{includeDefaultEnvs:u})),p.generateApplicationTypesFile(l,B),n("admin-globals.ts",r(p.generateAdminBindingBlock,p.adminBindingDescription))]};

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

@@ -0,0 +1,35 @@
+/**
+ * Composes the three semantic application file groups into one complete generated application.
+ *
+ * Code generation is split by responsibility rather than by output location, so each group can be
+ * generated on its own by a consumer that only needs part of a project:
+ *
+ * - domain-runtime files, in `./domain-runtime-files.js` — what a running configurator imports
+ * - standalone-application files, in `./standalone-app-files.js` — what a deployed application boots
+ * - project scaffolding, in `./project-scaffolding.js` — what configures the generated project
+ *
+ * Each group module documents the criterion that decides its membership, so a new template
+ * self-classifies into exactly one of them. This module owns only the aggregate and adds no files of
+ * its own: it concatenates the two application-file groups, in that order, into the `.phoenix`
+ * output, and spreads the scaffolding group's project-root buckets alongside them.
+ *
+ * Generated projects always bind phx globally, so the aggregate selects `globalPhxBindingStrategy`.
+ * A module-scoped binding is only meaningful to a consumer calling the domain-runtime group on its
+ * own, which is why the choice lives on that group rather than in these aggregate options.
+ *
+ * @module
+ */
+import { GeneratedApplication } from '../../core/index.js';
+import type { GenerateDomainRuntimeFilesOptions } from './domain-runtime-files.js';
+import type { GenerateProjectScaffoldingOptions } from './project-scaffolding.js';
+import type { GenerateStandaloneAppFilesOptions } from './standalone-app-files.js';
+/**
+ * Inputs required to generate a complete standalone application project.
+ *
+ * This is the union of the three group option types rather than their source: each group owns its
+ * own contract, and the all-in-one entry point is the compatibility surface derived from them. A
+ * field added to a group therefore reaches this type automatically.
+ */
+export interface GenerateApplicationCodeOptions extends GenerateDomainRuntimeFilesOptions, GenerateStandaloneAppFilesOptions, GenerateProjectScaffoldingOptions {
+}
+export declare const generateApplicationCode: (options: GenerateApplicationCodeOptions) => GeneratedApplication;

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

@@ -0,0 +1 @@
+import{GeneratedApplication as o}from"../../core/index.js";import{generateDomainRuntimeFiles as e,globalPhxBindingStrategy as i}from"./domain-runtime-files.js";import{generateProjectScaffolding as r}from"./project-scaffolding.js";import{generateStandaloneAppFiles as t}from"./standalone-app-files.js";export const generateApplicationCode=m=>o({files:[...e(m,i),...t(m)],...r(m)});

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

@@ -0,0 +1,21 @@
+/**
+ * Feature boundary for application code generation.
+ *
+ * Exports the aggregate generator and the three semantic group generators it composes. The
+ * templates barrel is deliberately not re-exported: individual file templates are an implementation
+ * detail of this folder, and `application-spec/index.ts` is a public package entry point.
+ *
+ * @module
+ */
+export { generateApplicationCode } from './generate-application-code.js';
+export type { GenerateApplicationCodeOptions } from './generate-application-code.js';
+export { generateDomainRuntimeFiles, globalPhxBindingStrategy, modulePhxBindingStrategy, } from './domain-runtime-files.js';
+export type { GenerateDomainRuntimeFilesOptions, PhxBindingStrategy } from './domain-runtime-files.js';
+export { generateStandaloneAppFiles } from './standalone-app-files.js';
+export type { GenerateStandaloneAppFilesOptions } from './standalone-app-files.js';
+export { generateStandaloneCommonAdminFiles, generateStandaloneDomainFiles } from './common-admin/index.js';
+export type { GenerateStandaloneCommonAdminFilesOptions, GenerateStandaloneDomainFilesOptions, } from './common-admin/index.js';
+export { generateApplicationSpecStoryFiles, getStoryTextFiles } from './story-files.js';
+export type { GenerateApplicationSpecStoryFilesOptions } from './story-files.js';
+export { agentSkillRoots, generateProjectScaffolding } from './project-scaffolding.js';
+export type { GeneratedProjectScaffolding, GenerateProjectScaffoldingOptions } from './project-scaffolding.js';

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

@@ -0,0 +1 @@
+export{generateApplicationCode}from"./generate-application-code.js";export{generateDomainRuntimeFiles,globalPhxBindingStrategy,modulePhxBindingStrategy}from"./domain-runtime-files.js";export{generateStandaloneAppFiles}from"./standalone-app-files.js";export{generateStandaloneCommonAdminFiles,generateStandaloneDomainFiles}from"./common-admin/index.js";export{generateApplicationSpecStoryFiles,getStoryTextFiles}from"./story-files.js";export{agentSkillRoots,generateProjectScaffolding}from"./project-scaffolding.js";

package/dist/application-spec/generate-application/code/project-scaffolding.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Generates the files that configure the generated project itself.
+ *
+ * Membership criterion: a file belongs to this group when it describes the project rather than the
+ * application — dependency and toolchain configuration, formatting rules, agent instructions, and
+ * the initial content a fresh project starts with. Nothing here is imported by the running
+ * configurator or served by the deployed application.
+ *
+ * Several templates merge with the project's existing content instead of overwriting it, so the
+ * already-authored files are read back out of the categorized project files here.
+ *
+ * @module
+ */
+import { GeneratedApplicationFile } from '../../core/index.js';
+import type { ApplicationSpec, CategorizedFiles } from '../../parse-application-files/index.js';
+/**
+ * Project-relative folders coding agents scan for project skills.
+ *
+ * Claude Code reads `.claude/skills`; Codex reads `.agents/skills`; Cursor reads both. Phoenix emits
+ * every Phoenix-owned skill into each root and owns only the `phoenix` and `phoenix-*` folders
+ * inside them, with everything in them — any other skill folder belongs to the project.
+ */
+export declare const agentSkillRoots: readonly ['.claude/skills', '.agents/skills'];
+/**
+ * Inputs required by generated-project configuration and initial project files.
+ *
+ * The SDK version pins the generated `package.json` dependency, `cliUseWorkspace` lets an explicit
+ * CLI flag override the spec's workspace mode, and the optional name and description populate the
+ * project metadata. The categorized files carry the project's existing `package.json` and `.gitignore`
+ * so those templates can merge rather than clobber, and the legacy cursor rules and `CLAUDE.md` so the
+ * SDK block can be stripped from them.
+ */
+export interface GenerateProjectScaffoldingOptions {
+    readonly applicationSpec: ApplicationSpec;
+    readonly categorizedFiles: CategorizedFiles;
+    readonly sdkVersion: string;
+    readonly cliUseWorkspace?: boolean;
+    readonly name?: string;
+    readonly description?: string;
+}
+/**
+ * Project-root file buckets produced independently from the application runtime files.
+ *
+ * The buckets are kept apart because they carry different write intent, which the caching layer
+ * acts on: `generatedProjectFiles` are content-diffed and rewritten whenever they differ,
+ * `initialProjectFiles` are written only when absent and are the project's to edit afterwards, and
+ * `prettierFiles` are separated so a writer can emit the formatting configuration ahead of the
+ * output it formats. `removedProjectFiles` lists project-relative paths of files earlier SDK versions
+ * generated that must no longer exist. As in the generated application bundle these buckets flow
+ * into, they express that intent without implementing the write behavior themselves.
+ */
+export interface GeneratedProjectScaffolding {
+    readonly generatedProjectFiles: readonly GeneratedApplicationFile[];
+    readonly initialProjectFiles: readonly GeneratedApplicationFile[];
+    readonly prettierFiles: readonly GeneratedApplicationFile[];
+    readonly removedProjectFiles: readonly string[];
+}
+export declare const generateProjectScaffolding: (options: GenerateProjectScaffoldingOptions) => GeneratedProjectScaffolding;

package/dist/application-spec/generate-application/code/project-scaffolding.js

@@ -0,0 +1,6 @@
+import{GeneratedApplicationFile as e}from"../../core/index.js";import{generateAgentsMd as t,generateApplicationSpecEnvCi as n,generateApplicationSpecEnvExample as r,generateApplicationSpecEslintConfig as o,generateApplicationSpecFavicon as i,generateApplicationSpecGitignore as a,generateApplicationSpecNvmrc as s,generateApplicationSpecPackageJson as c,generateApplicationSpecPrettierConfig as l,generateApplicationSpecPrettierIgnore as p,generateApplicationSpecPrivateAssetsReadme as m,generateApplicationSpecPublicAssetsReadme as f,generateApplicationSpecReadme as d,generateApplicationSpecRobotsTxt as g,generateApplicationSpecTsconfig as u,generateApplicationSpecWebhookImplementation as x,generateLinguiRcFile as v,generatePhoenixCliSkill as h,generatePhoenixCreateConfiguratorSkill as j,generatePhoenixCreateConfiguratorSkillReferences as k,generatePhoenixFeedbackSkill as b,generatePhoenixReviewSkill as E,generatePhoenixSkill as F,stripSdkMarkerContent as M}from"./templates/index.js";export const agentSkillRoots=[".claude/skills",".agents/skills"];let P=[{path:"CLAUDE.md",generatedPrefix:""},{path:".cursor/rules/phoenix.mdc",generatedPrefix:`---
+description: Phoenix SDK project rules
+globs:
+alwaysApply: true
+---
+`}],w=[".claude/commands/review.md",".cursor/commands/review.md"],A=(e,t)=>e.projectFiles.find(e=>e.file.name===t)?.file.content;export const generateProjectScaffolding=S=>{let D,{applicationSpec:R,categorizedFiles:$,sdkVersion:C,cliUseWorkspace:L,name:y,description:K}=S,G=A($,"package.json"),I=A($,".gitignore"),N=void 0!==L?L:R.appMetadata.workspace,T=(t=>{let n=[],r=[...w];for(let{path:o,generatedPrefix:i}of P){let a=A(t,o);if(void 0===a)continue;let s=M(a,i);void 0===s?r.push(o):s!==a&&n.push(e(o,s,{format:!1}))}return{strippedFiles:n,removedFiles:r}})($);return{generatedProjectFiles:[e("package.json",c({sdkVersion:C,useWorkspace:N,useClerk:R.appMetadata.useClerk??!1,name:y,description:K,existingContent:G})),e(".nvmrc",s(),{format:!1}),e(".linguirc",v(R.configurator.ui.availableLocales),{format:!1}),e("tsconfig.json",u()),e("eslint.config.js",o()),e(".gitignore",a(I)),...(D=[{name:"phoenix",content:F(),references:[]},{name:"phoenix-cli",content:h(),references:[]},{name:"phoenix-create-configurator",content:j(),references:k()},{name:"phoenix-feedback",content:b(),references:[]},{name:"phoenix-review",content:E(),references:[]}],agentSkillRoots.flatMap(t=>D.flatMap(n=>[e(`${t}/${n.name}/SKILL.md`,n.content),...n.references.map(r=>e(`${t}/${n.name}/${r.path}`,r.content))]))),...T.strippedFiles],initialProjectFiles:[e("README.md",d(y)),e("AGENTS.md",t()),e(".env.ci",n()),e(".env.example",r()),e("public/favicon.ico",i(),{binary:!0}),e("public/robots.txt",g(),{format:!1}),e("assets/public/README.md",f()),e("assets/private/README.md",m()),e("src/webhooks/index.ts",x())],prettierFiles:[e("prettier.config.js",l()),e(".prettierignore",p(),{format:!1})],removedProjectFiles:T.removedFiles}};

package/dist/application-spec/generate-application/code/standalone-app-files.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Generates the application files that only a standalone deployed application needs.
+ *
+ * Membership criterion: a file belongs to this group when it exists so the generated application
+ * can be served, mounted, or deployed on its own — HTML documents, browser entry points, embedding
+ * bootstraps, frontend and webhook configuration, and the optional editor. The running configurator
+ * never imports these to evaluate the domain; a host that already has a runtime can skip the whole
+ * group. Files the runtime does import belong to the domain-runtime group, and files that configure
+ * the generated project rather than the application belong to the project-scaffolding group.
+ *
+ * @module
+ */
+import { GeneratedApplicationFile } from '../../core/index.js';
+import type { ApplicationSpec, CategorizedFiles, RawMockTemplates } from '../../parse-application-files/index.js';
+/**
+ * Inputs required by standalone application entry points and deployment files.
+ *
+ * The project and environment slugs address the deployed environment the embedding bootstraps talk
+ * to, and `enableEditor` together with `inlineTemplates` and the raw mock templates decide whether
+ * and how the optional editor entry point is emitted. The categorized files are needed only to find
+ * the authored handlers that are implicitly registered or explicitly pinned into the webhook, not
+ * to bind the runtime.
+ */
+export interface GenerateStandaloneAppFilesOptions {
+    readonly applicationSpec: ApplicationSpec;
+    readonly categorizedFiles: CategorizedFiles;
+    readonly projectSlug: string;
+    readonly environmentSlug: string;
+    readonly enableEditor: boolean;
+    readonly inlineTemplates: boolean;
+    readonly rawMockTemplates: RawMockTemplates;
+}
+export declare const generateStandaloneAppFiles: (options: GenerateStandaloneAppFilesOptions) => readonly GeneratedApplicationFile[];

package/dist/application-spec/generate-application/code/standalone-app-files.js

@@ -0,0 +1 @@
+import{GeneratedApplicationFile as e}from"../../core/index.js";import{generateApplicationSpecAdminConfig as t,generateApplicationSpecAdminFile as a,generateApplicationSpecConfiguratorFile as o,generateApplicationSpecEditorFile as n,generateApplicationSpecEmbeddedAdmin as d,generateApplicationSpecEmbeddedConfigurator as p,generateApplicationSpecFrontendConfig as s,generateApplicationSpecHtmlAdminIndex as i,generateApplicationSpecHtmlIndex as m,generateApplicationSpecWebhookBuilders as r,generateApplicationSpecWebhookIndex as l,generateApplicationSpecWebhooksConfig as f}from"./templates/index.js";import{getWebhookHandlerFileNames as g}from"./webhook-safe-files.js";export const generateStandaloneAppFiles=b=>{let{applicationSpec:c,categorizedFiles:h,projectSlug:w,environmentSlug:x,enableEditor:M,inlineTemplates:T,rawMockTemplates:k}=b,u=k.templates,j=g(h.handlers);return[e("index.html",m(c.appMetadata.webComponentTag,M,c.appMetadata.pageTitle)),e("configurator.ts",o(c.appMetadata.webComponentTag)),e("admin.html",i(c.appMetadata.pageTitle)),e("admin.ts",a()),e("admin-config.ts",t()),e("frontend.config.ts",s(c)),e("webhooks.config.ts",f(c)),e("webhook.ts",l()),e("webhook-builders.ts",r(c,j)),e("embedded-admin.ts",d(w,x)),e("embedded-configurator.ts",p(w,x)),...M?[e("editor.tsx",n(c.appMetadata.webComponentTag,T,u,x))]:[]]};

package/dist/application-spec/generate-application/code/story-files.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generates the file set one application-spec Storybook story needs in its `.phoenix` directory.
+ *
+ * Membership criterion: a file belongs to this group when a Storybook story needs it to mount the
+ * configurator with an embedded editor and no server — the domain runtime files, the inlined
+ * project-file snapshot the editor starts from, the React wrapper, its story-dev ambient
+ * declaration, and the story's lingui configuration. Files that exist so a deployed application can
+ * be served belong to the standalone-app group, and files that configure a generated project belong
+ * to the project-scaffolding group.
+ *
+ * Stories are generated once per explicit story build. While `phoenix story dev` runs, authored
+ * changes reach the editor over its WebSocket instead of regenerating this group; see
+ * `docs/architecture/story-dev.md`.
+ *
+ * @module
+ */
+import { GeneratedApplicationFile } from '../../core/index.js';
+import type { PhoenixDefinitions, RawProjectFiles, TextFile } from '../../core/index.js';
+import type { Application } from '../../parse-application-files/index.js';
+/** Inputs for the application-spec story manifest emitted relative to one story's root directory. */
+export interface GenerateApplicationSpecStoryFilesOptions {
+    readonly application: Application;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly rawProjectFiles: RawProjectFiles;
+    readonly storyFolderName: string;
+    readonly storyName: string;
+}
+/**
+ * Narrows a story's project files to text content, rejecting binary assets.
+ *
+ * A story inlines its project files into generated TypeScript, so there is nowhere for binary
+ * content to live. Demos read their project from disk and are the place for binary assets.
+ */
+export declare const getStoryTextFiles: (rawProjectFiles: RawProjectFiles) => readonly TextFile[];
+export declare const generateApplicationSpecStoryFiles: (options: GenerateApplicationSpecStoryFilesOptions) => readonly GeneratedApplicationFile[];

package/dist/application-spec/generate-application/code/story-files.js

@@ -0,0 +1 @@
+import{GeneratedApplicationFile as e,isTextFile as t}from"../../core/index.js";import{generateDomainRuntimeFiles as i,modulePhxBindingStrategy as r}from"./domain-runtime-files.js";import{generateApplicationSpecStoryDevDeclaration as o,generateApplicationSpecStoryPhxModule as a,generateApplicationSpecStoryRawProjectFiles as n,generateApplicationSpecStoryWrapper as s,generateLinguiRcFile as l}from"./templates/index.js";let p=".phoenix";export const getStoryTextFiles=e=>{let i=e.files.find(e=>"binary"===e.kind);if(i)throw Error(`Cannot build application-spec story: "${i.name}" is binary. Stories inline text project files only; remove the binary asset or demonstrate this project in a demo instead.`);return e.files.filter(t)};export const generateApplicationSpecStoryFiles=t=>{let{application:c,phxDefinitions:m,rawProjectFiles:f,storyFolderName:d,storyName:u}=t,y=getStoryTextFiles(f);return[...i({applicationSpec:c.applicationSpec,categorizedFiles:c.categorizedFiles,phxDefinitions:m,includeDefaultEnvs:!1},r).map(t=>e(`${p}/${t.path}`,t.content,{binary:t.binary,format:t.format})),e(".linguirc",l([...c.applicationSpec.configurator.ui.availableLocales]),{format:!1}),e(`${p}/phx.ts`,a()),e(`${p}/raw-project-files.ts`,n(y,f.envs)),e(`${p}/${u}.tsx`,s(d,c.rawMockTemplates.templates)),e(`${p}/story-dev-virtual-module.d.ts`,o(d))]};

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

@@ -0,0 +1 @@
+export declare const generateApplicationSpecAdminConfig: () => string;

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

@@ -0,0 +1,13 @@
+import{autoHeader as n}from"../common/file-headers.js";export const generateApplicationSpecAdminConfig=()=>`${n("admin-config.ts","Admin configurator config — builds admin interface and wires admin components/elements.")}
+import { configuratorConfig } from './configurator-config.js'
+import { adminInterface } from './admin-globals.js'
+import { customAdminComponentOptics } from './admin-domain-code.js'
+import { customAdminElements, customFrontendAdminComponentOptics } from './admin-frontend-code.js'
+import { customElements } from './configurator-frontend-code.js'
+
+export const adminConfig = configuratorConfig
+  .withInterface(adminInterface)
+  .withAdminComponentOptics(customAdminComponentOptics)
+  .withAdminComponentOptics(customFrontendAdminComponentOptics)
+  .withElements([...customElements, ...customAdminElements])
+`;

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

@@ -0,0 +1,8 @@
+import { type ApplicationTypeImportRegistrar } from '../common/index.js';
+interface GenerateAdminCodeOptions {
+    readonly adminExpressionFiles: readonly string[];
+    readonly adminInvariantFiles: readonly string[];
+    readonly adminComponentFiles: readonly string[];
+}
+export declare const generateApplicationSpecAdminCode: (options: GenerateAdminCodeOptions, registerApplicationTypeImports?: ApplicationTypeImportRegistrar) => string;
+export {};

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

@@ -0,0 +1,17 @@
+import{autoHeader as n}from"../common/file-headers.js";import{CodeImports as t,skipApplicationTypeImports as e}from"../common/index.js";let s=(n,t)=>n.map((n,e)=>{let s=`../${n.replace(/\.tsx?$/,".js")}`;return`import ${t}${e} from '${s}'`}),i=(n,t="\n")=>n.length>0?"\n"+n.join(t)+"\n":"";export const generateApplicationSpecAdminCode=(o,a=e)=>{let{adminExpressionFiles:r,adminInvariantFiles:m,adminComponentFiles:d}=o,p=new t;for(let n of["AliasedExpressions","AliasedInvariants","DomainComponentOptic","SystemComponentTypeConstraint"])p.addTypeImport("@salsita-ai/sdk/domain",n);a(p,["Admin","FrontendData","PublishedData","SessionData"]);let c=[...s(r,"adminExpressions"),...s(m,"adminInvariants"),...s(d,"adminComponents")],A=r.map((n,t)=>`for (const [type, exprs] of Object.entries(adminExpressions${t})) {
+  mergedExpressions[type] = { ...mergedExpressions[type], ...exprs }
+}`),y=m.map((n,t)=>`for (const [type, invs] of Object.entries(adminInvariants${t})) {
+  mergedInvariants[type] = [...(mergedInvariants[type] ?? []), ...invs]
+}`),l=d.map((n,t)=>`adminComponents${t}`);return`${n("admin-domain-code.ts","Barrel file for user-authored admin domain code — expressions, invariants and components.")}
+${p.toString()}
+${i(c)}
+const mergedExpressions: Record<string, Record<string, unknown>> = {}
+${i(A,"\n\n")}
+export const customAdminExpressions = mergedExpressions as AliasedExpressions<Admin.AnyDomainEntity, Admin.RootEntity, PublishedData, SessionData, FrontendData, Admin.Aliases>
+
+const mergedInvariants: Record<string, ReadonlyArray<unknown>> = {}
+${i(y,"\n\n")}
+export const customAdminInvariants = mergedInvariants as AliasedInvariants<Admin.AnyDomainEntity, Admin.RootEntity, PublishedData, SessionData, FrontendData, Admin.Aliases, string>
+
+export const customAdminComponentOptics: ReadonlyArray<DomainComponentOptic<Admin.AnyDomainEntity, Admin.RootEntity, PublishedData, SessionData, FrontendData, Admin.AnyDomainEntity, SystemComponentTypeConstraint>> = [${l.join(", ")}].flat()
+`};

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

@@ -0,0 +1,7 @@
+import { type ApplicationTypeImportRegistrar } from '../common/index.js';
+interface GenerateAdminFrontendCodeOptions {
+    readonly adminElementFiles: readonly string[];
+    readonly adminComponentFiles: readonly string[];
+}
+export declare const generateApplicationSpecAdminFrontendCode: (options: GenerateAdminFrontendCodeOptions, registerApplicationTypeImports?: ApplicationTypeImportRegistrar) => string;
+export {};

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

@@ -0,0 +1,9 @@
+import{autoHeader as n}from"../common/file-headers.js";import{CodeImports as t,skipApplicationTypeImports as e}from"../common/index.js";let o=(n,t)=>n.map((n,e)=>{let o=`../${n.replace(/\.tsx?$/,".js")}`;return`import ${t}${e} from '${o}'`});export const generateApplicationSpecAdminFrontendCode=(m,i=e)=>{let{adminElementFiles:a,adminComponentFiles:r}=m,d=new t;for(let n of["DomainComponentOptic","ElementRegistration","SystemComponentTypeConstraint"])d.addTypeImport("@salsita-ai/sdk/domain",n);i(d,["Admin","FrontendData","PublishedData","SessionData"]);let s=[...o(a,"adminElements"),...o(r,"frontendAdminComponents")],p=a.map((n,t)=>`adminElements${t}`),l=r.map((n,t)=>`frontendAdminComponents${t}`);return`${n("admin-frontend-code.ts","Barrel file for user-authored admin frontend code — elements and frontend-only components. Needs phx.frontend.admin.")}
+${d.toString()}
+
+import './admin-globals.js'
+${s.length>0?"\n"+s.join("\n")+"\n":""}
+export const customAdminElements: readonly ElementRegistration[] = [${p.join(", ")}].flat()
+
+export const customFrontendAdminComponentOptics: ReadonlyArray<DomainComponentOptic<Admin.AnyDomainEntity, Admin.RootEntity, PublishedData, SessionData, FrontendData, Admin.AnyDomainEntity, SystemComponentTypeConstraint>> = [${l.join(", ")}].flat()
+`};

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

@@ -0,0 +1,3 @@
+export type AdminBindingBlockGenerator = () => string;
+export declare const generateAdminGlobalBindingBlock: AdminBindingBlockGenerator;
+export declare const generateApplicationSpecAdminGlobals: (generateBindingBlock?: AdminBindingBlockGenerator, description?: string) => string;

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

@@ -0,0 +1,11 @@
+import{autoHeader as e}from"../common/file-headers.js";export const generateAdminGlobalBindingBlock=()=>`
+// @ts-ignore - Initialize the globals
+globalThis.phx.frontend.admin = adminInterface
+`;export const generateApplicationSpecAdminGlobals=(n=generateAdminGlobalBindingBlock,i="Creates the admin interface and sets phx.frontend.admin — must run before admin user code imports.")=>`${e("admin-globals.ts",i)}
+import { createAdminInterface } from '@salsita-ai/sdk/admin'
+
+import './configurator-globals.js'
+import { configuratorBuilder } from './domain.js'
+
+export const adminInterface = createAdminInterface(configuratorBuilder)
+${n()}`;

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

@@ -0,0 +1 @@
+export declare const generateApplicationSpecAdminFile: () => string;

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

@@ -0,0 +1,10 @@
+import{autoHeader as i}from"../common/file-headers.js";export const generateApplicationSpecAdminFile=()=>`${i("admin.ts","Admin entry point — bootstraps the admin frontend application.")}
+import { mountStandaloneAdminApplication } from '@salsita-ai/sdk/application'
+
+import { adminConfig } from './admin-config.js'
+
+const config = adminConfig
+  .buildConfig()
+
+mountStandaloneAdminApplication(config)
+`;

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

@@ -0,0 +1 @@
+export declare const generateAgentsMd: () => string;

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

@@ -0,0 +1,2 @@
+import{sdkGuidanceSections as e}from"./common/sdk-content.js";export const generateAgentsMd=()=>`${[e.projectIntro,e.buildCommands,e.doNotEdit,"Phoenix SDK guidance lives in the `phoenix`, `phoenix-cli`, `phoenix-create-configurator`, `phoenix-feedback` and `phoenix-review` skills under `.claude/skills/` and `.agents/skills/`. Phoenix rewrites them on every sync, removes anything else inside their folders and removes other `phoenix`-prefixed skill folders, so to customise a skill, copy it to a folder whose name does not start with `phoenix`."].join("\n\n")}
+`;

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

@@ -0,0 +1,12 @@
+import type { PhoenixDefinitions } from '../../../core/phoenix-definitions.js';
+import type { ApplicationSpec } from '../../../parse-application-files/index.js';
+import { CodeImports } from '../common/code-imports.js';
+interface ApplicationSpecTypeDeclarations {
+    readonly declarations: string;
+    readonly imports: CodeImports;
+}
+/** Generates the application-owned declarations shared by global and module bindings. */
+export declare const generateApplicationSpecTypeDeclarations: (spec: ApplicationSpec, phxDefinitions: PhoenixDefinitions, indent: number) => ApplicationSpecTypeDeclarations;
+/** Generates the local application type module used by module-scoped phx bindings. */
+export declare const generateApplicationSpecTypesModule: (spec: ApplicationSpec, phxDefinitions: PhoenixDefinitions) => string;
+export {};

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

@@ -0,0 +1,10 @@
+import{CodeImports as e}from"../common/code-imports.js";import{autoHeader as o}from"../common/file-headers.js";import{generateStateTypeDecls as t}from"./domain-spec/index.js";import{generateDataSchemaTypeDecls as n,generateEntityExpressionComposites as i,generateExpressionTypeDecls as a,generateModelTypeDecls as s}from"./global-definition/index.js";export const generateApplicationSpecTypeDeclarations=(o,r,p)=>{let l=new e,d=p+2,m=" ".repeat(p),c=s(o.configurator.latestModel,r,l,p),f=[];for(let e of o.configurator.resolvedVersions.versionedModels){let o=`ModelV${e.version}`,t=s(e.modelVersion,r,l,d);f.push(`${m}namespace ${o} {
+${t}${m}}`)}let $=s(o.admin.latestModel,r,l,d),g=`${m}namespace Admin {
+${$}${m}}`,u=[];for(let e of o.admin.resolvedVersions.versionedModels){let o=`AdminV${e.version}`,t=s(e.modelVersion,r,l,d);u.push(`${m}namespace ${o} {
+${t}${m}}`)}let y=a(o.configurator.expressions,r,l,p),x=i(o.configurator.latestModel,o.configurator.expressions,l,p,""),M=[a(o.admin.expressions,r,l,d),i(o.admin.latestModel,o.admin.expressions,l,d,"Admin")].filter(Boolean).join("\n\n"),v=M?`${m}namespace Admin {
+${M}
+${m}}`:"",A=n(o,r,l,p),S=t({configuratorStates:o.configurator.states,adminStates:o.admin.states},p);return l.addTypeImport("@salsita-ai/sdk/domain","DomainEntityId"),{imports:l,declarations:[c,y,x,A,S,...f,g,v,...u].filter(Boolean).join("\n\n")}};export const generateApplicationSpecTypesModule=(e,t)=>{let{declarations:n,imports:i}=generateApplicationSpecTypeDeclarations(e,t,0);return`${o("application-types.ts","Story-local application, model and state types derived from the spec.")}
+${i.toTypeOnlyString(".phoenix/application-types.ts")}
+
+${n.replace(/^(\s*)(type|interface|namespace) /gm,"$1export $2 ")}
+`};