@eide/foir-cli 0.1.44 → 0.1.46

package/dist/cli.js

@@ -1,12 +1,8 @@
 #!/usr/bin/env node
-import {
-  findConfigFile,
-  loadConfigFile
-} from "./chunk-L642MYIL.js";
 
 // src/cli.ts
 import { config } from "dotenv";
-import { resolve as resolve6, dirname as dirname6 } from "path";
+import { resolve as resolve6, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { Command } from "commander";
@@ -218,21 +214,6 @@ async function resolveProjectContext(options) {
       };
     }
   }
-  try {
-    const { loadConfigProject } = await import("./loader-7VE4OF73.js");
-    const configProfile = await loadConfigProject();
-    if (configProfile) {
-      const project2 = await getProjectContext(configProfile);
-      if (project2) {
-        return {
-          project: project2,
-          source: "foir.config.ts",
-          profileName: configProfile
-        };
-      }
-    }
-  } catch {
-  }
   const defaultProfile = await getDefaultProfile();
   if (defaultProfile) {
     const project2 = await getProjectContext(defaultProfile);
@@ -516,7 +497,7 @@ var CLI_API_KEY_SCOPES = [
   "records:publish",
   "files:read",
   "files:write",
-  "extensions:read",
+  "configs:read",
   "operations:read",
   "operations:execute"
 ];
@@ -940,1717 +921,181 @@ function registerMediaCommands(program2, globalOpts) {
   );
 }
 
-// src/commands/pull.ts
-import { resolve } from "path";
+// src/commands/create-config.ts
 import chalk4 from "chalk";
+import inquirer2 from "inquirer";
 
-// src/config/pull-config.ts
-var DEFAULT_OUTPUT_DIR = "./src/generated";
-async function loadPullConfig(flags) {
-  let fileConfig = {};
-  const configPath = findConfigFile(flags.config);
-  if (configPath) {
-    const full = await loadConfigFile(configPath);
-    fileConfig = full.pull ?? {};
+// src/scaffold/scaffold.ts
+import * as fs4 from "fs";
+import * as path2 from "path";
+
+// src/scaffold/package-manager.ts
+import * as fs3 from "fs";
+import * as path from "path";
+function detectPackageManager() {
+  const lockFiles = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  let dir = process.cwd();
+  while (true) {
+    for (const { file, manager } of lockFiles) {
+      if (fs3.existsSync(path.join(dir, file))) {
+        return getManagerInfo(manager);
+      }
+    }
+    const parentDir = path.dirname(dir);
+    if (parentDir === dir) {
+      break;
+    }
+    dir = parentDir;
   }
-  let outputDir;
-  if (flags.out) {
-    outputDir = flags.out;
-  } else if (typeof fileConfig.output === "string") {
-    outputDir = fileConfig.output;
-  } else if (typeof fileConfig.output === "object" && fileConfig.output?.types) {
-    const legacyTypes = fileConfig.output.types;
-    outputDir = legacyTypes.replace(/\/types\/?$/, "") || DEFAULT_OUTPUT_DIR;
-  } else {
-    outputDir = DEFAULT_OUTPUT_DIR;
+  return getManagerInfo("npm");
+}
+function getManagerInfo(manager) {
+  switch (manager) {
+    case "pnpm":
+      return {
+        name: "pnpm",
+        installCommand: "pnpm install",
+        execCommand: "pnpm dlx"
+      };
+    case "yarn":
+      return {
+        name: "yarn",
+        installCommand: "yarn install",
+        execCommand: "yarn dlx"
+      };
+    case "npm":
+      return {
+        name: "npm",
+        installCommand: "npm install",
+        execCommand: "npx"
+      };
+  }
+}
+
+// src/scaffold/scaffold.ts
+async function scaffold(projectName, configType, apiUrl) {
+  const projectDir = path2.resolve(process.cwd(), projectName);
+  if (fs4.existsSync(projectDir)) {
+    throw new Error(
+      `Directory "${projectName}" already exists. Choose a different name or remove the existing directory.`
+    );
+  }
+  const files = getFiles(projectName, configType, apiUrl);
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path2.join(projectDir, filePath);
+    const dir = path2.dirname(fullPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(fullPath, content, "utf-8");
+  }
+  const pm = detectPackageManager();
+  console.log("  Files created:");
+  console.log();
+  for (const filePath of Object.keys(files)) {
+    console.log(`    ${filePath}`);
   }
-  const only = flags.only ? flags.only.split(",").map((s) => s.trim()) : fileConfig.only ?? [];
-  const includeInline = fileConfig.includeInline ?? true;
-  const prettier = flags.noPrettier ? false : fileConfig.prettier ?? true;
-  const dryRun = flags.dryRun ?? false;
+  console.log();
+  console.log("  Done! Next steps:");
+  console.log();
+  console.log(`    cd ${projectName}`);
+  console.log(`    ${pm.installCommand}`);
+  console.log(`    cp ui/.env.example ui/.env.local`);
+  console.log(`    cp api/.env.example api/.env.local`);
+  console.log(`    ${pm.name === "npm" ? "npm run" : pm.name} dev`);
+  console.log();
+}
+function getFiles(projectName, configType, apiUrl) {
   return {
-    output: { types: outputDir },
-    only,
-    includeInline,
-    prettier,
-    dryRun
+    // Root
+    "package.json": getRootPackageJson(projectName),
+    // Config manifest
+    "foir.config.ts": getFoirConfig(projectName, configType),
+    // UI (Vite SPA)
+    "ui/package.json": getUiPackageJson(projectName),
+    "ui/tsconfig.json": getUiTsconfig(),
+    "ui/vite.config.ts": getUiViteConfig(),
+    "ui/index.html": getUiIndexHtml(projectName),
+    "ui/.env.example": getUiEnvExample(apiUrl),
+    "ui/.gitignore": getUiGitignore(),
+    "ui/src/main.tsx": getUiMain(),
+    "ui/src/App.tsx": getUiApp(configType),
+    "ui/src/index.css": getUiCss(),
+    "ui/src/vite-env.d.ts": '/// <reference types="vite/client" />\n',
+    // API (Hono)
+    "api/package.json": getApiPackageJson(projectName),
+    "api/tsconfig.json": getApiTsconfig(),
+    "api/.env.example": getApiEnvExample(apiUrl),
+    "api/.gitignore": "node_modules\ndist\n.env\n.env.local\n",
+    "api/src/index.ts": getApiIndex(),
+    "api/src/routes/webhooks.ts": getApiWebhooks(),
+    "api/src/routes/health.ts": getApiHealth()
+  };
+}
+function getRootPackageJson(name) {
+  const pkg = {
+    name,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: 'concurrently "pnpm --filter ./ui dev" "pnpm --filter ./api dev"',
+      build: "pnpm --filter ./ui build && pnpm --filter ./api build"
+    },
+    devDependencies: {
+      concurrently: "^9.0.0",
+      "@eide/foir-cli": "^0.1.0"
+    }
   };
+  return JSON.stringify(pkg, null, 2) + "\n";
 }
+function getFoirConfig(name, configType) {
+  const displayName = name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return `import { defineConfig } from '@eide/foir-cli/configs';
 
-// src/graphql/generated.ts
-var GetCustomerProfileSchemaDocument = {
-  kind: "Document",
-  definitions: [
-    {
-      kind: "OperationDefinition",
-      operation: "query",
-      name: { kind: "Name", value: "GetCustomerProfileSchema" },
-      selectionSet: {
-        kind: "SelectionSet",
-        selections: [
-          {
-            kind: "Field",
-            name: { kind: "Name", value: "customerProfileSchema" },
-            selectionSet: {
-              kind: "SelectionSet",
-              selections: [
-                { kind: "Field", name: { kind: "Name", value: "id" } },
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "fields" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "key" } },
-                      { kind: "Field", name: { kind: "Name", value: "type" } },
-                      { kind: "Field", name: { kind: "Name", value: "label" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "required" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "helpText" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "defaultValue" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "config" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "validation" },
-                        selectionSet: {
-                          kind: "SelectionSet",
-                          selections: [
-                            {
-                              kind: "Field",
-                              name: { kind: "Name", value: "rule" }
-                            },
-                            {
-                              kind: "Field",
-                              name: { kind: "Name", value: "value" }
-                            },
-                            {
-                              kind: "Field",
-                              name: { kind: "Name", value: "message" }
-                            }
-                          ]
-                        }
-                      }
-                    ]
-                  }
-                },
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "publicFields" }
-                },
-                { kind: "Field", name: { kind: "Name", value: "version" } },
-                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
-                { kind: "Field", name: { kind: "Name", value: "updatedAt" } }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-var ModelsForCodegenDocument = {
-  kind: "Document",
-  definitions: [
-    {
-      kind: "OperationDefinition",
-      operation: "query",
-      name: { kind: "Name", value: "ModelsForCodegen" },
-      variableDefinitions: [
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "search" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "String" } }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "limit" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "offset" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-        }
-      ],
-      selectionSet: {
-        kind: "SelectionSet",
-        selections: [
-          {
-            kind: "Field",
-            name: { kind: "Name", value: "models" },
-            arguments: [
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "search" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "search" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "limit" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "limit" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "offset" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "offset" }
-                }
-              }
-            ],
-            selectionSet: {
-              kind: "SelectionSet",
-              selections: [
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "items" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "id" } },
-                      { kind: "Field", name: { kind: "Name", value: "key" } },
-                      { kind: "Field", name: { kind: "Name", value: "name" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "pluralName" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "description" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "category" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "fields" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "config" }
-                      },
-                      { kind: "Field", name: { kind: "Name", value: "hooks" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "createdAt" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "updatedAt" }
-                      }
-                    ]
-                  }
-                },
-                { kind: "Field", name: { kind: "Name", value: "total" } }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-var GlobalSearchDocument = {
-  kind: "Document",
-  definitions: [
-    {
-      kind: "OperationDefinition",
-      operation: "query",
-      name: { kind: "Name", value: "GlobalSearch" },
-      variableDefinitions: [
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "query" }
-          },
-          type: {
-            kind: "NonNullType",
-            type: {
-              kind: "NamedType",
-              name: { kind: "Name", value: "String" }
-            }
-          }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "limit" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "modelKeys" }
-          },
-          type: {
-            kind: "ListType",
-            type: {
-              kind: "NonNullType",
-              type: {
-                kind: "NamedType",
-                name: { kind: "Name", value: "String" }
-              }
-            }
-          }
-        },
-        {
-          kind: "VariableDefinition",
-          variable: {
-            kind: "Variable",
-            name: { kind: "Name", value: "includeMedia" }
-          },
-          type: { kind: "NamedType", name: { kind: "Name", value: "Boolean" } }
-        }
-      ],
-      selectionSet: {
-        kind: "SelectionSet",
-        selections: [
-          {
-            kind: "Field",
-            name: { kind: "Name", value: "globalSearch" },
-            arguments: [
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "query" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "query" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "limit" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "limit" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "modelKeys" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "modelKeys" }
-                }
-              },
-              {
-                kind: "Argument",
-                name: { kind: "Name", value: "includeMedia" },
-                value: {
-                  kind: "Variable",
-                  name: { kind: "Name", value: "includeMedia" }
-                }
-              }
-            ],
-            selectionSet: {
-              kind: "SelectionSet",
-              selections: [
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "records" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "id" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "modelKey" }
-                      },
-                      { kind: "Field", name: { kind: "Name", value: "title" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "naturalKey" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "subtitle" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "updatedAt" }
-                      }
-                    ]
-                  }
-                },
-                {
-                  kind: "Field",
-                  name: { kind: "Name", value: "media" },
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                      { kind: "Field", name: { kind: "Name", value: "id" } },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "fileName" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "altText" }
-                      },
-                      {
-                        kind: "Field",
-                        name: { kind: "Name", value: "fileUrl" }
-                      }
-                    ]
-                  }
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-
-// src/codegen/fetch-models.ts
-function normalizeConfig(raw) {
-  return {
-    records: Boolean(raw.records ?? true),
-    inline: Boolean(raw.inline ?? false),
-    publicApi: Boolean(raw.publicApi ?? false),
-    versioning: Boolean(raw.versioning ?? false),
-    publishing: Boolean(raw.publishing ?? false),
-    variants: Boolean(raw.variants ?? false),
-    customerScoped: Boolean(raw.customerScoped ?? false),
-    sharing: raw.sharing ? {
-      enabled: Boolean(
-        raw.sharing.enabled ?? false
-      ),
-      requireAcceptance: Boolean(
-        raw.sharing.requireAcceptance ?? true
-      )
-    } : void 0,
-    embeddings: raw.embeddings
-  };
-}
-function normalizeField(raw) {
-  const field = raw;
-  const options = { ...field.options ?? {} };
-  const resolvedType = field.type === "composite" && field.config?.schema ? field.config.schema : field.type;
-  if (!options.itemType) {
-    const resolved = field.itemType ?? field.config?.itemType ?? field.config?.itemSchema;
-    if (resolved) {
-      options.itemType = resolved;
-    }
-  }
-  if (field.config?.minItems !== void 0 && options.minItems === void 0) {
-    options.minItems = field.config.minItems;
-  }
-  if (field.config?.maxItems !== void 0 && options.maxItems === void 0) {
-    options.maxItems = field.config.maxItems;
-  }
-  return {
-    key: field.key,
-    type: resolvedType,
-    label: field.label,
-    required: field.required,
-    helpText: field.helpText,
-    options: Object.keys(options).length > 0 ? options : void 0
-  };
-}
-async function fetchModelsForCodegen(client) {
-  const data = await client.request(ModelsForCodegenDocument, {
-    limit: 500
-  });
-  return data.models.items.map((item) => ({
-    key: item.key,
-    name: item.name,
-    pluralName: item.pluralName ?? void 0,
-    description: item.description ?? void 0,
-    category: item.category ?? void 0,
-    fields: (item.fields ?? []).map(
-      (f) => normalizeField(f)
-    ),
-    config: normalizeConfig(item.config ?? {}),
-    hooks: item.hooks ?? void 0
-  }));
-}
-function filterModels(models, options) {
-  let filtered = models;
-  if (options.only && options.only.length > 0) {
-    const onlySet = new Set(options.only);
-    filtered = filtered.filter((m) => onlySet.has(m.key));
-  }
-  if (!options.includeInline) {
-    filtered = filtered.filter((m) => m.config.records);
-  }
-  return filtered;
-}
-
-// src/codegen/fetch-customer-profile-schema.ts
-async function fetchCustomerProfileSchema(client) {
-  const data = await client.request(GetCustomerProfileSchemaDocument);
-  if (!data.customerProfileSchema) return null;
-  return {
-    id: data.customerProfileSchema.id,
-    version: data.customerProfileSchema.version,
-    fields: (data.customerProfileSchema.fields ?? []).map((f) => ({
-      key: f.key,
-      type: f.type,
-      label: f.label,
-      required: f.required ?? void 0,
-      helpText: f.helpText ?? void 0,
-      options: f.config
-    }))
-  };
-}
-
-// src/codegen/field-mapping.ts
-var PRIMITIVE_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "richtext",
-  "number",
-  "boolean",
-  "email",
-  "phone",
-  "url",
-  "date",
-  "image",
-  "video",
-  "file",
-  "currency",
-  "select",
-  "multiselect",
-  "json",
-  "list",
-  "reference",
-  "link",
-  "flexible",
-  "model"
-]);
-function isPrimitiveFieldType(type) {
-  return PRIMITIVE_FIELD_TYPES.has(type);
-}
-var FIELD_TYPE_MAPPING = {
-  text: { outputType: "string", inputType: "string" },
-  richtext: {
-    outputType: "RichtextValue",
-    inputType: "RichtextValue",
-    needsImport: "field-types"
-  },
-  number: { outputType: "number", inputType: "number" },
-  boolean: { outputType: "boolean", inputType: "boolean" },
-  email: { outputType: "string", inputType: "string" },
-  phone: { outputType: "string", inputType: "string" },
-  url: { outputType: "string", inputType: "string" },
-  date: { outputType: "Date", inputType: "string" },
-  image: {
-    outputType: "ImageValue",
-    inputType: "string",
-    needsImport: "field-types"
-  },
-  video: {
-    outputType: "VideoValue",
-    inputType: "string",
-    needsImport: "field-types"
-  },
-  file: {
-    outputType: "FileValue",
-    inputType: "string",
-    needsImport: "field-types"
-  },
-  currency: {
-    outputType: "CurrencyValue",
-    inputType: "CurrencyValue",
-    needsImport: "field-types"
-  },
-  select: { outputType: "string", inputType: "string" },
-  multiselect: { outputType: "string[]", inputType: "string[]" },
-  json: { outputType: "unknown", inputType: "unknown" },
-  list: { outputType: "unknown[]", inputType: "unknown[]" },
-  flexible: {
-    outputType: "FlexibleFieldItem[]",
-    inputType: "FlexibleFieldItem[]",
-    needsImport: "field-types"
-  },
-  reference: {
-    outputType: "ReferenceValue",
-    inputType: "ReferenceValue",
-    needsImport: "field-types"
-  },
-  link: {
-    outputType: "LinkValue",
-    inputType: "LinkValue",
-    needsImport: "field-types"
-  },
-  model: { outputType: "string", inputType: "string" }
-};
-function getFieldType(field, mode = "output") {
-  if (!field?.type) return "unknown";
-  const mapping = FIELD_TYPE_MAPPING[field.type];
-  if (!mapping) {
-    if (isPrimitiveFieldType(field.type)) return "unknown";
-    return toPascalCase(field.type);
-  }
-  let tsType = mode === "output" ? mapping.outputType : mapping.inputType;
-  if (field.type === "select" && field.options?.options) {
-    const options = field.options.options;
-    if (options.length > 0) {
-      tsType = options.map((o) => `'${o.value}'`).join(" | ");
-    }
-  }
-  if (field.type === "multiselect" && field.options?.options) {
-    const options = field.options.options;
-    if (options.length > 0) {
-      tsType = `(${options.map((o) => `'${o.value}'`).join(" | ")})[]`;
-    }
-  }
-  if (field.type === "list" && field.options?.itemType) {
-    const itemType = field.options.itemType;
-    const itemMapping = FIELD_TYPE_MAPPING[itemType];
-    if (itemMapping) {
-      tsType = `${mode === "output" ? itemMapping.outputType : itemMapping.inputType}[]`;
-    } else if (!isPrimitiveFieldType(itemType)) {
-      tsType = `${toPascalCase(itemType)}[]`;
-    }
-  }
-  return tsType;
-}
-function getReferenceTypeModelRefs(fields) {
-  const refs = /* @__PURE__ */ new Set();
-  for (const field of fields) {
-    if (field.type === "reference" && field.options?.referenceTypes) {
-      for (const rt of field.options.referenceTypes) {
-        refs.add(rt);
-      }
-    }
-  }
-  return refs;
-}
-function getInlineSchemaReferences(fields) {
-  const refs = /* @__PURE__ */ new Set();
-  for (const field of fields) {
-    if (!isPrimitiveFieldType(field.type) && !FIELD_TYPE_MAPPING[field.type]) {
-      refs.add(field.type);
-    }
-    if (field.type === "list" && field.options?.itemType) {
-      const itemType = field.options.itemType;
-      if (!isPrimitiveFieldType(itemType) && !FIELD_TYPE_MAPPING[itemType]) {
-        refs.add(itemType);
-      }
-    }
-  }
-  return refs;
-}
-function toCamelCase(str) {
-  if (!str) return "unknown";
-  return str.replace(
-    /[-_]([a-z])/g,
-    (_, letter) => letter.toUpperCase()
-  );
-}
-function toPascalCase(str) {
-  if (!str) return "Unknown";
-  const camel = toCamelCase(str);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-function sanitizeFieldName(key) {
-  if (!key) return "unknown";
-  const camel = toCamelCase(key);
-  if (/^[0-9]/.test(camel)) return `_${camel}`;
-  return camel;
-}
-function generateFieldDef(field) {
-  const parts = [];
-  parts.push(`key: '${field.key ?? "unknown"}'`);
-  parts.push(`type: '${field.type ?? "text"}'`);
-  parts.push(
-    `label: '${(field.label ?? field.key ?? "Unknown").replace(/'/g, "\\'")}'`
-  );
-  if (field.required) parts.push("required: true");
-  if (field.helpText)
-    parts.push(`helpText: '${field.helpText.replace(/'/g, "\\'")}'`);
-  if (field.type === "text" && field.options) {
-    if (field.options.maxLength)
-      parts.push(`maxLength: ${field.options.maxLength}`);
-    if (field.options.minLength)
-      parts.push(`minLength: ${field.options.minLength}`);
-  }
-  if (field.type === "number" && field.options) {
-    if (field.options.min !== void 0)
-      parts.push(`min: ${field.options.min}`);
-    if (field.options.max !== void 0)
-      parts.push(`max: ${field.options.max}`);
-    if (field.options.step !== void 0)
-      parts.push(`step: ${field.options.step}`);
-  }
-  if ((field.type === "select" || field.type === "multiselect") && field.options?.options) {
-    const options = field.options.options;
-    const optionsStr = options.filter((o) => o.value !== void 0).map((o) => {
-      const label = (o.label ?? o.value ?? "").replace(/'/g, "\\'");
-      const value = (o.value ?? "").replace(/'/g, "\\'");
-      return `{ label: '${label}', value: '${value}' }`;
-    }).join(", ");
-    parts.push(`options: [${optionsStr}]`);
-  }
-  if (field.type === "reference" && field.options?.referenceTypes) {
-    const refTypes = field.options.referenceTypes;
-    parts.push(`referenceTypes: [${refTypes.map((t) => `'${t}'`).join(", ")}]`);
-    if (field.options.multiple) parts.push("multiple: true");
-  }
-  if (field.type === "list" && field.options?.itemType) {
-    parts.push(`itemType: '${field.options.itemType}'`);
-    if (field.options.minItems !== void 0)
-      parts.push(`minItems: ${field.options.minItems}`);
-    if (field.options.maxItems !== void 0)
-      parts.push(`maxItems: ${field.options.maxItems}`);
-  }
-  if ((field.type === "image" || field.type === "video" || field.type === "file") && field.options) {
-    if (field.options.allowedTypes) {
-      const types = field.options.allowedTypes;
-      parts.push(`allowedTypes: [${types.map((t) => `'${t}'`).join(", ")}]`);
-    }
-    if (field.options.maxSize) parts.push(`maxSize: ${field.options.maxSize}`);
-  }
-  return `{ ${parts.join(", ")} }`;
-}
-
-// src/codegen/generators/model-types.ts
-function isInlineOnlyModel(model) {
-  return model.config.inline && !model.config.records;
-}
-function generateModelTypes(model, allModels) {
-  const typeName = toPascalCase(model.key);
-  const configName = toCamelCase(model.key) + "Config";
-  const fields = model.fields ?? [];
-  const fieldTypeImports = getFieldTypeImportsForFields(fields);
-  const inlineSchemaRefs = getInlineSchemaReferences(fields);
-  const referenceModelRefs = getReferenceTypeModelRefs(fields);
-  let code = buildImportStatements(
-    model,
-    fieldTypeImports,
-    inlineSchemaRefs,
-    referenceModelRefs,
-    allModels
-  );
-  if (isInlineOnlyModel(model)) {
-    code += generateDataInterface(model, fields, typeName, allModels);
-    return code;
-  }
-  code += generateConfigObject(model, fields, configName);
-  code += "\n";
-  code += generateDataInterface(model, fields, typeName + "Data", allModels);
-  return code;
-}
-function buildImportStatements(model, fieldTypeImports, inlineSchemaRefs, referenceModelRefs, allModels) {
-  const imports = [];
-  if (fieldTypeImports.size > 0) {
-    const types = Array.from(fieldTypeImports).sort().join(", ");
-    imports.push(`import type { ${types} } from '@eide/foir-client';`);
-  }
-  const allModelRefKeys = /* @__PURE__ */ new Set([
-    ...inlineSchemaRefs,
-    ...referenceModelRefs
-  ]);
-  for (const refKey of allModelRefKeys) {
-    if (refKey === model.key) continue;
-    const refModel = allModels.find((m) => m.key === refKey);
-    if (refModel) {
-      const refTypeName = isInlineOnlyModel(refModel) ? toPascalCase(refKey) : toPascalCase(refKey) + "Data";
-      imports.push(`import type { ${refTypeName} } from './${refKey}.js';`);
-    }
-  }
-  return imports.length > 0 ? imports.join("\n") + "\n\n" : "";
-}
-function generateConfigObject(model, fields, configName) {
-  const lines = [];
-  lines.push("/**");
-  lines.push(` * ${model.name} Configuration`);
-  if (model.description) lines.push(` * ${model.description}`);
-  lines.push(` *`);
-  lines.push(` * @generated from model '${model.key}'`);
-  lines.push(" */");
-  const escapedName = (model.name ?? model.key).replace(/'/g, "\\'");
-  lines.push(`export const ${configName} = {`);
-  lines.push(`  key: '${model.key}',`);
-  lines.push(`  name: '${escapedName}',`);
-  if (model.description) {
-    lines.push(`  description: '${model.description.replace(/'/g, "\\'")}',`);
-  }
-  lines.push("");
-  lines.push("  // Capability flags");
-  lines.push(`  records: ${model.config.records},`);
-  lines.push(`  inline: ${model.config.inline},`);
-  lines.push(`  publicApi: ${model.config.publicApi},`);
-  lines.push(`  versioning: ${model.config.versioning},`);
-  lines.push(`  publishing: ${model.config.publishing},`);
-  lines.push(`  variants: ${model.config.variants},`);
-  lines.push(`  customerScoped: ${model.config.customerScoped},`);
-  if (model.config.embeddings?.enabled) {
-    lines.push("");
-    lines.push("  // Embeddings");
-    lines.push(
-      `  embeddings: ${JSON.stringify(model.config.embeddings, null, 4).replace(/\n/g, "\n  ")},`
-    );
-  }
-  if (model.hooks && Object.keys(model.hooks).length > 0) {
-    lines.push("");
-    lines.push("  // Lifecycle hooks");
-    lines.push(
-      `  hooks: ${JSON.stringify(model.hooks, null, 4).replace(/\n/g, "\n  ")},`
-    );
-  } else {
-    lines.push("");
-    lines.push("  hooks: {},");
-  }
-  lines.push("");
-  lines.push("  // Field definitions");
-  if (fields.length === 0) {
-    lines.push("  fieldDefs: [],");
-  } else {
-    lines.push("  fieldDefs: [");
-    for (const field of fields) {
-      lines.push(`    ${generateFieldDef(field)},`);
-    }
-    lines.push("  ],");
-  }
-  lines.push("} as const;");
-  return lines.join("\n") + "\n";
-}
-function generateDataInterface(model, fields, interfaceName, allModels) {
-  const lines = [];
-  lines.push("/**");
-  lines.push(` * ${model.name} Data`);
-  lines.push(` * Field values only \u2014 no system fields`);
-  lines.push(` *`);
-  lines.push(` * @generated from model '${model.key}'`);
-  lines.push(" */");
-  lines.push(`export interface ${interfaceName} {`);
-  for (const field of fields) {
-    const fieldName = sanitizeFieldName(field.key);
-    let fieldType = getFieldType(field, "output");
-    const refModel = allModels.find((m) => m.key === field.type);
-    if (refModel && !isInlineOnlyModel(refModel)) {
-      fieldType = toPascalCase(field.type) + "Data";
-    }
-    if (field.type === "list" && field.options?.itemType) {
-      const itemRefModel = allModels.find(
-        (m) => m.key === field.options.itemType
-      );
-      if (itemRefModel && !isInlineOnlyModel(itemRefModel)) {
-        fieldType = toPascalCase(field.options.itemType) + "Data[]";
-      }
-    }
-    if (field.type === "reference" && field.options?.referenceTypes) {
-      const refTypes = field.options.referenceTypes;
-      const resolvedPreviewTypes = [];
-      for (const refKey of refTypes) {
-        const targetModel = allModels.find((m) => m.key === refKey);
-        if (targetModel) {
-          const targetTypeName = isInlineOnlyModel(targetModel) ? toPascalCase(refKey) : toPascalCase(refKey) + "Data";
-          resolvedPreviewTypes.push(`Partial<${targetTypeName}>`);
-        }
-      }
-      if (resolvedPreviewTypes.length === refTypes.length && resolvedPreviewTypes.length > 0) {
-        fieldType = `ReferenceValue<${resolvedPreviewTypes.join(" | ")}>`;
-      }
-    }
-    const optional = field.required ? "" : "?";
-    const comment = field.helpText ? `  /** ${field.helpText} */
-` : "";
-    lines.push(comment + `  ${fieldName}${optional}: ${fieldType};`);
-  }
-  lines.push("}");
-  return lines.join("\n") + "\n";
-}
-function getFieldTypeImportsForFields(fields) {
-  const imports = /* @__PURE__ */ new Set();
-  for (const field of fields) {
-    const mapping = FIELD_TYPE_MAPPING[field.type];
-    if (mapping?.needsImport === "field-types") {
-      imports.add(mapping.outputType.replace(/\[\]$/, ""));
-    }
-    if (field.type === "list" && field.options?.itemType) {
-      const itemMapping = FIELD_TYPE_MAPPING[field.options.itemType];
-      if (itemMapping?.needsImport === "field-types") {
-        imports.add(itemMapping.outputType.replace(/\[\]$/, ""));
-      }
-    }
-  }
-  return imports;
-}
-
-// src/codegen/generators/model-index.ts
-function isInlineOnlyModel2(model) {
-  return model.config.inline && !model.config.records;
-}
-function generateModelIndex(models) {
-  let code = `/**
- * Model Types and Configs \u2014 Generated re-exports
- *
- * @generated by foir \u2014 DO NOT EDIT MANUALLY
- */
-
-`;
-  for (const model of models) {
-    const typeName = toPascalCase(model.key);
-    const configName = toCamelCase(model.key) + "Config";
-    if (isInlineOnlyModel2(model)) {
-      code += `export type { ${typeName} } from './${model.key}.js';
-`;
-    } else {
-      code += `export { ${configName} } from './${model.key}.js';
-`;
-      code += `export type { ${typeName}Data } from './${model.key}.js';
-`;
-      if (model.config.publicApi) {
-        code += `export type { ${typeName}Where, ${typeName}SortField } from './${model.key}.filters.js';
-`;
-      }
-    }
-  }
-  return code;
-}
-
-// src/codegen/generators/client-factory.ts
-function generateClientFactory(models, hasCustomerProfile) {
-  const publicModels = models.filter(
-    (m) => m.config.publicApi && m.config.records
-  );
-  const lines = [];
-  lines.push(`/**
- * Typed Foir client for this project.
- *
- * @generated by foir \u2014 DO NOT EDIT MANUALLY
- */
-
-import {
-  createBaseClient,
-  createModelAccessor,
-  createAuthClient,
-  createFilesClient,
-  createNotificationsClient,
-  createSharingClient,
-  createSearchClient,
-  createProfileClient,
-  createOperationsClient,
-  type ClientConfig,
-  type ModelAccessor,
-  type FoirClient,
-} from '@eide/foir-client';
-`);
-  for (const model of publicModels) {
-    const typeName = toPascalCase(model.key);
-    const dataType = `${typeName}Data`;
-    const whereType = `${typeName}Where`;
-    const sortType = `${typeName}SortField`;
-    lines.push(
-      `import type { ${dataType}, ${whereType}, ${sortType} } from './models/${model.key}.js';`
-    );
-  }
-  if (hasCustomerProfile) {
-    lines.push(
-      `import type { CustomerProfileData } from './models/customer-profile.js';`
-    );
-  }
-  lines.push("");
-  lines.push("export interface TypedClient extends FoirClient {");
-  for (const model of publicModels) {
-    const typeName = toPascalCase(model.key);
-    const accessorName = toCamelCase(model.key);
-    const dataType = `${typeName}Data`;
-    const whereType = `${typeName}Where`;
-    const sortType = `${typeName}SortField`;
-    lines.push(`  ${accessorName}: ModelAccessor<${dataType}, ${whereType}, ${sortType}>;`);
-  }
-  if (hasCustomerProfile) {
-    lines.push(
-      `  profile: ReturnType<typeof createProfileClient<CustomerProfileData>>;`
-    );
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push("export function createClient(config: ClientConfig): TypedClient {");
-  lines.push("  const base = createBaseClient(config);");
-  lines.push("");
-  lines.push("  return {");
-  lines.push("    auth: createAuthClient(base),");
-  lines.push("    files: createFilesClient(base),");
-  lines.push("    notifications: createNotificationsClient(base),");
-  lines.push("    sharing: createSharingClient(base),");
-  lines.push("    search: createSearchClient(base),");
-  if (hasCustomerProfile) {
-    lines.push("    profile: createProfileClient<CustomerProfileData>(base),");
-  } else {
-    lines.push("    profile: createProfileClient(base),");
-  }
-  lines.push("    operations: createOperationsClient(base),");
-  for (const model of publicModels) {
-    const typeName = toPascalCase(model.key);
-    const accessorName = toCamelCase(model.key);
-    const dataType = `${typeName}Data`;
-    const whereType = `${typeName}Where`;
-    const sortType = `${typeName}SortField`;
-    lines.push(
-      `    ${accessorName}: createModelAccessor<${dataType}, ${whereType}, ${sortType}>(base, '${model.key}'),`
-    );
-  }
-  lines.push(`    model<TData = unknown>(modelKey: string) {`);
-  lines.push(`      return createModelAccessor<TData>(base, modelKey);`);
-  lines.push(`    },`);
-  lines.push("    request: base.request,");
-  lines.push("    setCustomerToken: base.setCustomerToken,");
-  lines.push("    setLocale: base.setLocale,");
-  lines.push("    setPreview: base.setPreview,");
-  lines.push("  } as TypedClient;");
-  lines.push("}");
-  lines.push("");
-  lines.push("// Re-export types from @eide/foir-client for convenience");
-  lines.push(`export type {
-  ClientConfig,
-  TypedRecord,
-  TypedList,
-  ModelAccessor,
-  JsonValue,
-  ImageValue,
-  VideoValue,
-  FileValue,
-  LinkValue,
-  ReferenceValue,
-  FlexibleFieldItem,
-  RichtextValue,
-  CurrencyValue,
-  SelectMap,
-  ApplySelect,
-  FoirClient,
-} from '@eide/foir-client';`);
-  lines.push("");
-  for (const model of publicModels) {
-    const typeName = toPascalCase(model.key);
-    const dataType = `${typeName}Data`;
-    const whereType = `${typeName}Where`;
-    const sortType = `${typeName}SortField`;
-    lines.push(
-      `export type { ${dataType}, ${whereType}, ${sortType} } from './models/${model.key}.js';`
-    );
-  }
-  if (hasCustomerProfile) {
-    lines.push(
-      `export type { CustomerProfileData } from './models/customer-profile.js';`
-    );
-  }
-  return lines.join("\n") + "\n";
-}
-
-// src/codegen/generators/schema-manifest.ts
-function generateSchemaManifest(models, cpSchema) {
-  const manifest = {
-    $schema: "https://foir.io/schema/v1.json",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    models: {}
-  };
-  for (const model of models) {
-    manifest.models[model.key] = {
-      name: model.name,
-      pluralName: model.pluralName,
-      description: model.description,
-      category: model.category,
-      config: model.config,
-      fields: model.fields.map((f) => ({
-        key: f.key,
-        type: f.type,
-        label: f.label,
-        required: f.required,
-        helpText: f.helpText,
-        options: f.options
-      }))
-    };
-  }
-  if (cpSchema && cpSchema.fields.length > 0) {
-    manifest.customerProfile = {
-      fields: cpSchema.fields.map((f) => ({
-        key: f.key,
-        type: f.type,
-        label: f.label,
-        required: f.required,
-        helpText: f.helpText,
-        options: f.options
-      }))
-    };
-  }
-  return JSON.stringify(manifest, null, 2) + "\n";
-}
-
-// src/codegen/generators/model-filters.ts
-function isInlineOnlyModel3(model) {
-  return model.config.inline && !model.config.records;
-}
-function getFilterType(fieldType) {
-  switch (fieldType) {
-    case "text":
-    case "richtext":
-    case "email":
-    case "phone":
-    case "url":
-    case "select":
-      return "StringFilter";
-    case "number":
-    case "currency":
-      return "NumberFilter";
-    case "boolean":
-      return "BooleanFilter";
-    case "date":
-      return "DateFilter";
-    default:
-      return null;
-  }
-}
-function isSortable(fieldType) {
-  return ["text", "number", "date", "boolean", "email", "url", "select"].includes(fieldType);
-}
-function generateModelWhere(model) {
-  if (isInlineOnlyModel3(model)) return "";
-  const typeName = toPascalCase(model.key);
-  const whereName = `${typeName}Where`;
-  const fields = model.fields ?? [];
-  const filterImports = /* @__PURE__ */ new Set();
-  const filterFields = [];
-  for (const field of fields) {
-    const filterType = getFilterType(field.type);
-    if (filterType) {
-      filterImports.add(filterType);
-      const fieldName = sanitizeFieldName(field.key);
-      filterFields.push(`  ${fieldName}?: ${filterType};`);
-    }
-  }
-  filterImports.add("DateFilter");
-  filterFields.push("  createdAt?: DateFilter;");
-  filterFields.push("  updatedAt?: DateFilter;");
-  const imports = Array.from(filterImports).sort().join(", ");
-  const lines = [];
-  lines.push(`import type { ${imports} } from '@eide/foir-client';`);
-  lines.push("");
-  lines.push(`export interface ${whereName} {`);
-  lines.push(...filterFields);
-  lines.push(`  AND?: ${whereName}[];`);
-  lines.push(`  OR?: ${whereName}[];`);
-  lines.push(`  NOT?: ${whereName};`);
-  lines.push("}");
-  return lines.join("\n") + "\n";
-}
-function generateModelSortField(model) {
-  if (isInlineOnlyModel3(model)) return "";
-  const typeName = toPascalCase(model.key);
-  const sortName = `${typeName}SortField`;
-  const fields = model.fields ?? [];
-  const sortableFields = [];
-  for (const field of fields) {
-    if (isSortable(field.type)) {
-      sortableFields.push(`'${field.key}'`);
-    }
-  }
-  sortableFields.push(`'createdAt'`);
-  sortableFields.push(`'updatedAt'`);
-  const unique = [...new Set(sortableFields)];
-  return `export type ${sortName} = ${unique.join(" | ")};
-`;
-}
-
-// src/codegen/generators/model-zod.ts
-function isInlineOnlyModel4(model) {
-  return model.config.inline && !model.config.records;
-}
-function getZodExpression(field, allModels) {
-  const imports = /* @__PURE__ */ new Set();
-  let expr;
-  switch (field.type) {
-    case "text":
-    case "email":
-    case "phone":
-    case "url": {
-      imports.add("textField");
-      const opts = [];
-      if (field.options?.maxLength) opts.push(`maxLength: ${field.options.maxLength}`);
-      if (field.options?.minLength) opts.push(`minLength: ${field.options.minLength}`);
-      if (field.options?.pattern) opts.push(`pattern: '${field.options.pattern}'`);
-      expr = opts.length > 0 ? `textField({ ${opts.join(", ")} })` : `textField()`;
-      break;
-    }
-    case "number": {
-      imports.add("numberField");
-      const opts = [];
-      if (field.options?.min !== void 0) opts.push(`min: ${field.options.min}`);
-      if (field.options?.max !== void 0) opts.push(`max: ${field.options.max}`);
-      expr = opts.length > 0 ? `numberField({ ${opts.join(", ")} })` : `numberField()`;
-      break;
-    }
-    case "boolean":
-      imports.add("booleanField");
-      expr = "booleanField()";
-      break;
-    case "date":
-      imports.add("dateField");
-      expr = "dateField()";
-      break;
-    case "richtext":
-      imports.add("richtextValueSchema");
-      expr = "richtextValueSchema";
-      break;
-    case "image":
-      imports.add("imageValueSchema");
-      expr = "imageValueSchema";
-      break;
-    case "video":
-      imports.add("videoValueSchema");
-      expr = "videoValueSchema";
-      break;
-    case "file":
-      imports.add("fileValueSchema");
-      expr = "fileValueSchema";
-      break;
-    case "currency":
-      imports.add("currencyValueSchema");
-      expr = "currencyValueSchema";
-      break;
-    case "link":
-      imports.add("linkValueSchema");
-      expr = "linkValueSchema";
-      break;
-    case "reference":
-      imports.add("referenceValueSchema");
-      expr = "referenceValueSchema";
-      break;
-    case "select": {
-      if (field.options?.options) {
-        imports.add("selectField");
-        const options = field.options.options;
-        const values = options.map((o) => `'${o.value}'`).join(", ");
-        expr = `selectField([${values}])`;
-      } else {
-        expr = "z.string()";
-      }
-      break;
-    }
-    case "multiselect": {
-      if (field.options?.options) {
-        imports.add("multiselectField");
-        const options = field.options.options;
-        const values = options.map((o) => `'${o.value}'`).join(", ");
-        expr = `multiselectField([${values}])`;
-      } else {
-        expr = "z.array(z.string())";
-      }
-      break;
-    }
-    case "flexible":
-      imports.add("flexibleFieldItemSchema");
-      expr = "z.array(flexibleFieldItemSchema)";
-      break;
-    case "json":
-      imports.add("jsonValueSchema");
-      expr = "jsonValueSchema";
-      break;
-    case "list": {
-      if (field.options?.itemType) {
-        const itemType = field.options.itemType;
-        const refModel = allModels.find((m) => m.key === itemType);
-        if (refModel) {
-          const refSchemaName = `${toPascalCase(itemType)}${isInlineOnlyModel4(refModel) ? "" : "Data"}Schema`;
-          expr = `z.array(${refSchemaName})`;
-        } else {
-          imports.add("jsonValueSchema");
-          expr = "z.array(jsonValueSchema)";
-        }
-      } else {
-        imports.add("jsonValueSchema");
-        expr = "z.array(jsonValueSchema)";
-      }
-      break;
-    }
-    default: {
-      const refModel = allModels.find((m) => m.key === field.type);
-      if (refModel) {
-        const refSchemaName = `${toPascalCase(field.type)}${isInlineOnlyModel4(refModel) ? "" : "Data"}Schema`;
-        expr = refSchemaName;
-      } else {
-        imports.add("jsonValueSchema");
-        expr = "jsonValueSchema";
-      }
-    }
-  }
-  if (!field.required) {
-    expr = `${expr}.optional()`;
-  }
-  return { expression: expr, imports };
-}
-function generateModelZodSchema(model, allModels) {
-  const typeName = toPascalCase(model.key);
-  const schemaName = isInlineOnlyModel4(model) ? `${typeName}Schema` : `${typeName}DataSchema`;
-  const fields = model.fields ?? [];
-  if (fields.length === 0) {
-    return `import { z } from '@eide/foir-client/validation';
-
-export const ${schemaName} = z.object({});
-`;
-  }
-  const allImports = /* @__PURE__ */ new Set();
-  const fieldLines = [];
-  const inlineSchemaImports = [];
-  for (const field of fields) {
-    const { expression, imports } = getZodExpression(field, allModels);
-    for (const imp of imports) allImports.add(imp);
-    const fieldName = sanitizeFieldName(field.key);
-    fieldLines.push(`  ${fieldName}: ${expression},`);
-    if (!isPrimitiveFieldType(field.type) && field.type !== "list") {
-      const refModel = allModels.find((m) => m.key === field.type);
-      if (refModel && refModel.key !== model.key) {
-        const refSchemaName = `${toPascalCase(field.type)}${isInlineOnlyModel4(refModel) ? "" : "Data"}Schema`;
-        inlineSchemaImports.push(
-          `import { ${refSchemaName} } from './${field.type}.zod.js';`
-        );
-      }
-    }
-    if (field.type === "list" && field.options?.itemType) {
-      const itemType = field.options.itemType;
-      const refModel = allModels.find((m) => m.key === itemType);
-      if (refModel && refModel.key !== model.key) {
-        const refSchemaName = `${toPascalCase(itemType)}${isInlineOnlyModel4(refModel) ? "" : "Data"}Schema`;
-        inlineSchemaImports.push(
-          `import { ${refSchemaName} } from './${itemType}.zod.js';`
-        );
-      }
-    }
-  }
-  const lines = [];
-  lines.push(`/**`);
-  lines.push(` * Zod validation schema for ${model.name}`);
-  lines.push(` *`);
-  lines.push(` * @generated by foir \u2014 DO NOT EDIT MANUALLY`);
-  lines.push(` */`);
-  lines.push("");
-  lines.push(`import { z } from '@eide/foir-client/validation';`);
-  if (allImports.size > 0) {
-    const sorted = Array.from(allImports).sort();
-    lines.push(`import { ${sorted.join(", ")} } from '@eide/foir-client/validation';`);
-  }
-  const uniqueInlineImports = [...new Set(inlineSchemaImports)];
-  for (const imp of uniqueInlineImports) {
-    lines.push(imp);
-  }
-  lines.push("");
-  lines.push(`export const ${schemaName} = z.object({`);
-  lines.push(...fieldLines);
-  lines.push("});");
-  lines.push("");
-  lines.push(`export type ${isInlineOnlyModel4(model) ? typeName : typeName + "Data"}Validated = z.infer<typeof ${schemaName}>;`);
-  return lines.join("\n") + "\n";
-}
-
-// src/codegen/generators/customer-profile-types.ts
-function generateCustomerProfileTypes(schema) {
-  const fields = schema.fields ?? [];
-  const fieldTypeImports = getFieldTypeImportsForFields2(fields);
-  let code = `/**
- * Customer Profile Types
- *
- * @generated by foir from customer profile schema (version ${schema.version}) \u2014 DO NOT EDIT MANUALLY
- */
-
-`;
-  if (fieldTypeImports.size > 0) {
-    const types = Array.from(fieldTypeImports).sort().join(", ");
-    code += `import type { ${types} } from '../field-types.js';
-
-`;
-  }
-  code += `/**
- * Customer Profile Data
- * Typed field values for customer profiles
- *
- * @generated from customer profile schema (version ${schema.version})
- */
-`;
-  code += `export interface CustomerProfileData {
-`;
-  for (const field of fields) {
-    const fieldName = sanitizeFieldName(field.key);
-    const fieldType = getFieldType(field, "output");
-    const optional = field.required ? "" : "?";
-    if (field.helpText) {
-      code += `  /** ${field.helpText} */
-`;
-    }
-    code += `  ${fieldName}${optional}: ${fieldType};
-`;
-  }
-  code += `}
-`;
-  return code;
-}
-function getFieldTypeImportsForFields2(fields) {
-  const imports = /* @__PURE__ */ new Set();
-  for (const field of fields) {
-    const mapping = FIELD_TYPE_MAPPING[field.type];
-    if (mapping?.needsImport === "field-types") {
-      imports.add(mapping.outputType);
-    }
-  }
-  return imports;
-}
-
-// src/codegen/write-files.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname as dirname2 } from "path";
-async function writeGeneratedFile(filePath, content, usePrettier = true) {
-  await mkdir(dirname2(filePath), { recursive: true });
-  let formattedContent = content;
-  const isSwift = filePath.endsWith(".swift");
-  if (usePrettier && !isSwift) {
-    try {
-      const prettier = await import("prettier");
-      const parser = filePath.endsWith(".graphql") ? "graphql" : "typescript";
-      formattedContent = await prettier.format(content, {
-        parser,
-        semi: true,
-        singleQuote: true,
-        trailingComma: "es5",
-        printWidth: 100
-      });
-    } catch {
-    }
-  }
-  await writeFile(filePath, formattedContent, "utf-8");
-}
-async function writeFiles(files, usePrettier = true) {
-  await Promise.all(
-    files.map(
-      (file) => writeGeneratedFile(file.path, file.content, usePrettier)
-    )
-  );
-}
-
-// src/commands/pull.ts
-function registerPullCommand(program2, globalOpts) {
-  program2.command("pull").description(
-    "Generate typed client, model types, and validation schemas from platform models"
-  ).option("--config <path>", "Path to config file").option("--only <models>", "Comma-separated model keys to generate").option("--no-prettier", "Skip Prettier formatting").option("--dry-run", "Show what would be generated without writing").option("--out <dir>", "Override output directory").action(
-    withErrorHandler(
-      globalOpts,
-      async (cmdOpts) => {
-        const opts = globalOpts();
-        const flags = {
-          config: cmdOpts.config,
-          only: cmdOpts.only,
-          noPrettier: cmdOpts.prettier === false,
-          dryRun: !!cmdOpts.dryRun,
-          out: cmdOpts.out
-        };
-        const config2 = await loadPullConfig(flags);
-        const client = await createClient(opts);
-        console.log(chalk4.dim("Fetching models\u2026"));
-        const [allModels, cpSchema] = await Promise.all([
-          fetchModelsForCodegen(client),
-          fetchCustomerProfileSchema(client)
-        ]);
-        if (allModels.length === 0 && !cpSchema) {
-          console.log(chalk4.yellow("No models found. Nothing to generate."));
-          return;
-        }
-        const models = filterModels(allModels, {
-          only: config2.only.length > 0 ? config2.only : void 0,
-          includeInline: config2.includeInline
-        });
-        console.log(
-          chalk4.dim(
-            `Found ${allModels.length} model(s), generating for ${models.length}.`
-          )
-        );
-        const cwd = process.cwd();
-        const outDir = resolve(cwd, config2.output.types);
-        const modelsDir = resolve(outDir, "models");
-        const files = [];
-        const hasCustomerProfile = !!(cpSchema && cpSchema.fields.length > 0);
-        const publicModels = models.filter(
-          (m) => m.config.publicApi && m.config.records
-        );
-        for (const model of models) {
-          files.push({
-            path: resolve(modelsDir, `${model.key}.ts`),
-            content: generateModelTypes(model, models)
-          });
-          files.push({
-            path: resolve(modelsDir, `${model.key}.zod.ts`),
-            content: generateModelZodSchema(model, models)
-          });
-        }
-        for (const model of publicModels) {
-          const whereCode = generateModelWhere(model);
-          const sortCode = generateModelSortField(model);
-          if (whereCode || sortCode) {
-            files.push({
-              path: resolve(modelsDir, `${model.key}.filters.ts`),
-              content: `/**
- * Filter & sort types for ${model.name}
- *
- * @generated by foir \u2014 DO NOT EDIT MANUALLY
- */
-
-${whereCode}
-${sortCode}`
-            });
-          }
-        }
-        if (hasCustomerProfile) {
-          files.push({
-            path: resolve(modelsDir, "customer-profile.ts"),
-            content: generateCustomerProfileTypes(cpSchema)
-          });
-        }
-        files.push({
-          path: resolve(modelsDir, "index.ts"),
-          content: generateModelIndex(models)
-        });
-        files.push({
-          path: resolve(outDir, "client.ts"),
-          content: generateClientFactory(publicModels, hasCustomerProfile)
-        });
-        files.push({
-          path: resolve(outDir, "schema.json"),
-          content: generateSchemaManifest(models, cpSchema)
-        });
-        files.push({
-          path: resolve(outDir, "index.ts"),
-          content: generateRootIndex(hasCustomerProfile)
-        });
-        if (config2.dryRun) {
-          console.log(
-            chalk4.bold("\nDry run \u2014 files that would be generated:\n")
-          );
-          for (const file of files) {
-            const rel = file.path.replace(cwd + "/", "");
-            console.log(`  ${chalk4.green("+")} ${rel}`);
-          }
-          console.log(`
-${chalk4.dim(`${files.length} file(s) total`)}`);
-          return;
-        }
-        await writeFiles(files, config2.prettier);
-        const cpSuffix = hasCustomerProfile ? " + customer profile" : "";
-        console.log(
-          chalk4.green(`
-\u2713 Generated ${files.length} file(s)`) + chalk4.dim(
-            ` (${models.length} model(s), ${publicModels.length} typed accessor(s)${cpSuffix})`
-          )
-        );
-        console.log(chalk4.dim(`  Output: ${outDir}`));
-      }
-    )
-  );
-}
-function generateRootIndex(includeCustomerProfile) {
-  let code = `/**
- * Generated Foir client and model types.
- *
- * @generated by foir \u2014 DO NOT EDIT MANUALLY
- */
-
-export { createClient } from './client.js';
-export type { TypedClient } from './client.js';
-export * from './models/index.js';
-`;
-  if (includeCustomerProfile) {
-    code += `export type { CustomerProfileData } from './models/customer-profile.js';
-`;
-  }
-  return code;
-}
-
-// src/commands/create-extension.ts
-import chalk5 from "chalk";
-import inquirer2 from "inquirer";
-
-// src/scaffold/scaffold.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
-
-// src/scaffold/package-manager.ts
-import * as fs3 from "fs";
-import * as path from "path";
-function detectPackageManager() {
-  const lockFiles = [
-    { file: "pnpm-lock.yaml", manager: "pnpm" },
-    { file: "yarn.lock", manager: "yarn" },
-    { file: "package-lock.json", manager: "npm" }
-  ];
-  let dir = process.cwd();
-  while (true) {
-    for (const { file, manager } of lockFiles) {
-      if (fs3.existsSync(path.join(dir, file))) {
-        return getManagerInfo(manager);
-      }
-    }
-    const parentDir = path.dirname(dir);
-    if (parentDir === dir) {
-      break;
-    }
-    dir = parentDir;
-  }
-  return getManagerInfo("npm");
-}
-function getManagerInfo(manager) {
-  switch (manager) {
-    case "pnpm":
-      return {
-        name: "pnpm",
-        installCommand: "pnpm install",
-        execCommand: "pnpm dlx"
-      };
-    case "yarn":
-      return {
-        name: "yarn",
-        installCommand: "yarn install",
-        execCommand: "yarn dlx"
-      };
-    case "npm":
-      return {
-        name: "npm",
-        installCommand: "npm install",
-        execCommand: "npx"
-      };
-  }
-}
-
-// src/scaffold/scaffold.ts
-async function scaffold(projectName, extensionType, apiUrl) {
-  const projectDir = path2.resolve(process.cwd(), projectName);
-  if (fs4.existsSync(projectDir)) {
-    throw new Error(
-      `Directory "${projectName}" already exists. Choose a different name or remove the existing directory.`
-    );
-  }
-  const files = getFiles(projectName, extensionType, apiUrl);
-  for (const [filePath, content] of Object.entries(files)) {
-    const fullPath = path2.join(projectDir, filePath);
-    const dir = path2.dirname(fullPath);
-    if (!fs4.existsSync(dir)) {
-      fs4.mkdirSync(dir, { recursive: true });
-    }
-    fs4.writeFileSync(fullPath, content, "utf-8");
-  }
-  const pm = detectPackageManager();
-  console.log("  Files created:");
-  console.log();
-  for (const filePath of Object.keys(files)) {
-    console.log(`    ${filePath}`);
-  }
-  console.log();
-  console.log("  Done! Next steps:");
-  console.log();
-  console.log(`    cd ${projectName}`);
-  console.log(`    ${pm.installCommand}`);
-  console.log(`    cp ui/.env.example ui/.env.local`);
-  console.log(`    cp api/.env.example api/.env.local`);
-  console.log(`    ${pm.name === "npm" ? "npm run" : pm.name} dev`);
-  console.log();
-}
-function getFiles(projectName, extensionType, apiUrl) {
-  return {
-    // Root
-    "package.json": getRootPackageJson(projectName),
-    "extension.manifest.json": getManifest(projectName, extensionType),
-    // UI (Vite SPA)
-    "ui/package.json": getUiPackageJson(projectName),
-    "ui/tsconfig.json": getUiTsconfig(),
-    "ui/vite.config.ts": getUiViteConfig(),
-    "ui/index.html": getUiIndexHtml(projectName),
-    "ui/.env.example": getUiEnvExample(apiUrl),
-    "ui/.gitignore": getUiGitignore(),
-    "ui/src/main.tsx": getUiMain(),
-    "ui/src/App.tsx": getUiApp(extensionType),
-    "ui/src/index.css": getUiCss(),
-    "ui/src/vite-env.d.ts": '/// <reference types="vite/client" />\n',
-    // API (Hono)
-    "api/package.json": getApiPackageJson(projectName),
-    "api/tsconfig.json": getApiTsconfig(),
-    "api/.env.example": getApiEnvExample(apiUrl),
-    "api/.gitignore": "node_modules\ndist\n.env\n.env.local\n",
-    "api/src/index.ts": getApiIndex(),
-    "api/src/routes/webhooks.ts": getApiWebhooks(),
-    "api/src/routes/health.ts": getApiHealth(),
-    "api/src/lib/platform.ts": getApiPlatform()
-  };
-}
-function getRootPackageJson(name) {
-  const pkg = {
-    name,
-    version: "0.1.0",
-    private: true,
-    scripts: {
-      dev: 'concurrently "pnpm --filter ./ui dev" "pnpm --filter ./api dev"',
-      build: "pnpm --filter ./ui build && pnpm --filter ./api build"
-    },
-    devDependencies: {
-      concurrently: "^9.0.0"
-    }
-  };
-  return JSON.stringify(pkg, null, 2) + "\n";
-}
-function getManifest(name, extensionType) {
-  const manifest = {
-    name: name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
-    version: "0.1.0",
-    type: extensionType,
-    description: `${extensionType} extension`,
-    entityTypes: []
-  };
-  return JSON.stringify(manifest, null, 2) + "\n";
-}
-function getUiPackageJson(name) {
-  const pkg = {
-    name: `${name}-ui`,
-    version: "0.1.0",
-    private: true,
-    type: "module",
-    scripts: {
-      dev: "vite",
-      build: "tsc && vite build",
-      preview: "vite preview"
-    },
-    dependencies: {
-      "@eide/extension-sdk": "^0.1.0",
-      react: "^19.0.0",
-      "react-dom": "^19.0.0"
-    },
-    devDependencies: {
-      "@tailwindcss/vite": "^4.0.6",
-      "@types/react": "^19.0.0",
-      "@types/react-dom": "^19.0.0",
-      "@vitejs/plugin-react": "^4.3.4",
-      tailwindcss: "^4.0.0",
-      typescript: "^5.0.0",
-      vite: "^6.0.7"
+export default defineConfig({
+  key: '${name}',
+  name: '${displayName}',
+  configType: '${configType}',
+
+  // Uncomment and configure as needed:
+  // models: [],
+  // operations: [],
+  // schedules: [],
+  // hooks: [],
+  // segments: [],
+  // authProviders: [],
+  // placements: [],
+});
+`;
+}
+function getUiPackageJson(name) {
+  const pkg = {
+    name: `${name}-ui`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc && vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      "@eide/foir-editor-sdk": "^0.1.0",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0"
+    },
+    devDependencies: {
+      "@tailwindcss/vite": "^4.0.6",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0",
+      "@vitejs/plugin-react": "^4.3.4",
+      tailwindcss: "^4.0.0",
+      typescript: "^5.0.0",
+      vite: "^6.0.7"
     }
   };
   return JSON.stringify(pkg, null, 2) + "\n";
@@ -2736,13 +1181,13 @@ dist
 function getUiMain() {
   return `import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
-import { ExtensionProvider, useExtension } from '@eide/extension-sdk';
+import { EditorProvider, useEditor } from '@eide/foir-editor-sdk';
 import { useEffect } from 'react';
 import { App } from './App';
 import './index.css';
 
 function ThemeSync({ children }: { children: React.ReactNode }) {
-  const { theme } = useExtension();
+  const { theme } = useEditor();
 
   useEffect(() => {
     const root = document.documentElement;
@@ -2755,17 +1200,17 @@ function ThemeSync({ children }: { children: React.ReactNode }) {
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <ExtensionProvider>
+    <EditorProvider>
       <ThemeSync>
         <App />
       </ThemeSync>
-    </ExtensionProvider>
+    </EditorProvider>
   </StrictMode>
 );
 `;
 }
-function getUiApp(extensionType) {
-  switch (extensionType) {
+function getUiApp(configType) {
+  switch (configType) {
     case "custom-editor":
       return getCustomEditorApp();
     case "widget":
@@ -2775,10 +1220,10 @@ function getUiApp(extensionType) {
   }
 }
 function getCustomEditorApp() {
-  return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+  return `import { useEditor, useAutoResize } from '@eide/foir-editor-sdk';
 
 export function App() {
-  const { isReady, init, updateField, setDirty } = useExtension();
+  const { isReady, init, updateField, setDirty } = useEditor();
   const containerRef = useAutoResize({ minHeight: 600 });
 
   if (!isReady) return null;
@@ -2786,7 +1231,7 @@ export function App() {
   return (
     <div ref={containerRef} className="p-6 space-y-4">
       <h1 className="text-lg font-semibold">
-        Editing: {init?.entityModelKey}
+        Editing: {init?.modelKey}
       </h1>
       <p className="text-sm text-gray-500">
         Record: {init?.recordId}
@@ -2798,10 +1243,10 @@ export function App() {
 `;
 }
 function getWidgetApp() {
-  return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+  return `import { useEditor, useAutoResize } from '@eide/foir-editor-sdk';
 
 export function App() {
-  const { isReady, init, client } = useExtension();
+  const { isReady, init, client } = useEditor();
   const containerRef = useAutoResize({ minHeight: 300 });
 
   if (!isReady) return null;
@@ -2810,7 +1255,7 @@ export function App() {
     <div ref={containerRef} className="p-6 space-y-4">
       <h2 className="text-lg font-semibold">Dashboard Widget</h2>
       <p className="text-sm text-gray-500">
-        Connected to: {init?.entityModelKey}
+        Connected to: {init?.modelKey}
       </p>
       {/* Add your widget content here */}
     </div>
@@ -2819,19 +1264,19 @@ export function App() {
 `;
 }
 function getWorkflowApp() {
-  return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+  return `import { useEditor, useAutoResize } from '@eide/foir-editor-sdk';
 
 export function App() {
-  const { isReady, init, client, requestSave } = useExtension();
+  const { isReady, init, client, requestSave } = useEditor();
   const containerRef = useAutoResize({ minHeight: 400 });
 
   if (!isReady) return null;
 
   return (
     <div ref={containerRef} className="p-6 space-y-4">
-      <h1 className="text-lg font-semibold">Workflow Extension</h1>
+      <h1 className="text-lg font-semibold">Workflow Config</h1>
       <p className="text-sm text-gray-500">
-        Processing: {init?.entityModelKey} / {init?.recordId}
+        Processing: {init?.modelKey} / {init?.recordId}
       </p>
       {/* Add your workflow steps here */}
     </div>
@@ -2871,7 +1316,7 @@ function getApiPackageJson(name) {
       start: "node dist/index.js"
     },
     dependencies: {
-      "@eide/extension-sdk": "^0.1.0",
+      "@eide/foir-editor-sdk": "^0.1.0",
       hono: "^4.0.0",
       "@hono/node-server": "^1.0.0"
     },
@@ -2907,8 +1352,8 @@ function getApiEnvExample(apiUrl) {
 PLATFORM_BASE_URL=${baseUrl}
 PLATFORM_API_KEY=sk_your_api_key_here
 
-# Extension
-EXTENSION_KEY=${"{your-extension-key}"}
+# Config
+CONFIG_KEY=${"{your-config-key}"}
 WEBHOOK_SECRET=your_webhook_secret_here
 
 # Server
@@ -2929,25 +1374,25 @@ app.route('/', health);
 
 const port = parseInt(process.env.PORT || '3002', 10);
 
-console.log(\`Extension API running on http://localhost:\${port}\`);
+console.log(\`Config API running on http://localhost:\${port}\`);
 
 serve({ fetch: app.fetch, port });
 `;
 }
 function getApiWebhooks() {
   return `import { Hono } from 'hono';
-import { verifyWebhookSignature } from '@eide/extension-sdk/server';
+import { verifyWebhookSignature } from '@eide/foir-editor-sdk/server';
 
 const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET || '';
 
 export const webhooks = new Hono();
 
 /**
- * Receive entity lifecycle events from the platform.
+ * Receive record lifecycle events from the platform.
  */
-webhooks.post('/entity-changed', async (c) => {
+webhooks.post('/record-changed', async (c) => {
   const body = await c.req.text();
-  const signature = c.req.header('x-eide-signature') ?? '';
+  const signature = c.req.header('x-foir-signature') ?? '';
 
   const valid = await verifyWebhookSignature(body, signature, WEBHOOK_SECRET);
   if (!valid) {
@@ -2955,7 +1400,7 @@ webhooks.post('/entity-changed', async (c) => {
   }
 
   const payload = JSON.parse(body);
-  console.log('[Webhook] Entity changed:', payload.event, payload.entityId);
+  console.log('[Webhook] Record changed:', payload.event, payload.recordId);
 
   // TODO: Handle the event (sync, transform, notify, etc.)
 
@@ -2973,36 +1418,14 @@ health.get('/health', (c) => {
 });
 `;
 }
-function getApiPlatform() {
-  return `import { createExtensionClient } from '@eide/extension-sdk/server';
-
-/**
- * Pre-configured platform client for this extension.
- *
- * Uses env vars for configuration:
- * - PLATFORM_BASE_URL: Platform API base URL
- * - PLATFORM_API_KEY: Project-scoped API key (sk_*)
- * - EXTENSION_KEY: This extension's extension key
- */
-export const platform = createExtensionClient({
-  baseUrl: process.env.PLATFORM_BASE_URL || 'http://localhost:4000',
-  apiKey: process.env.PLATFORM_API_KEY || '',
-  extensionKey: process.env.EXTENSION_KEY || '',
-});
-`;
-}
 
-// src/commands/create-extension.ts
-var EXTENSION_TYPES = [
-  "custom-editor",
-  "workflow",
-  "widget"
-];
-function isValidExtensionType(value) {
-  return EXTENSION_TYPES.includes(value);
+// src/commands/create-config.ts
+var CONFIG_TYPES = ["custom-editor", "workflow", "widget"];
+function isValidConfigType(value) {
+  return CONFIG_TYPES.includes(value);
 }
-function registerCreateExtensionCommand(program2, globalOpts) {
-  program2.command("create-extension [name]").description("Scaffold a new Foir extension").option("--type <type>", "Extension type: custom-editor, workflow, widget").option(
+function registerCreateConfigCommand(program2, globalOpts) {
+  program2.command("create-config [name]").description("Scaffold a new Foir config").option("--type <type>", "Config type: custom-editor, workflow, widget").option(
     "--api-url <url>",
     "Platform API URL",
     "http://localhost:4000/graphql"
@@ -3011,48 +1434,206 @@ function registerCreateExtensionCommand(program2, globalOpts) {
       globalOpts,
       async (name, cmdOpts) => {
         console.log();
-        console.log(chalk5.bold("  Create Foir Extension"));
-        console.log(chalk5.gray("  ---------------------"));
+        console.log(chalk4.bold("  Create Foir Config"));
+        console.log(chalk4.gray("  ------------------"));
         console.log();
-        let extensionName = name;
-        if (!extensionName) {
+        let configName = name;
+        if (!configName) {
           const { inputName } = await inquirer2.prompt([
             {
               type: "input",
               name: "inputName",
-              message: "Extension name:",
-              default: "my-extension"
+              message: "Config name:",
+              default: "my-config"
             }
           ]);
-          extensionName = inputName;
+          configName = inputName;
         }
-        let extensionType;
-        if (cmdOpts?.type && isValidExtensionType(cmdOpts.type)) {
-          extensionType = cmdOpts.type;
+        let configType;
+        if (cmdOpts?.type && isValidConfigType(cmdOpts.type)) {
+          configType = cmdOpts.type;
         } else {
           const { selectedType } = await inquirer2.prompt([
             {
               type: "list",
               name: "selectedType",
-              message: "Extension type:",
-              choices: EXTENSION_TYPES,
+              message: "Config type:",
+              choices: CONFIG_TYPES,
               default: "custom-editor"
             }
           ]);
-          extensionType = selectedType;
+          configType = selectedType;
         }
         const apiUrl = cmdOpts?.apiUrl ?? "http://localhost:4000/graphql";
         console.log();
         console.log(
-          `  Scaffolding ${chalk5.cyan(`"${extensionName}"`)} (${extensionType})...`
+          `  Scaffolding ${chalk4.cyan(`"${configName}"`)} (${configType})...`
         );
         console.log();
-        await scaffold(extensionName, extensionType, apiUrl);
+        await scaffold(configName, configType, apiUrl);
       }
     )
   );
 }
 
+// src/graphql/generated.ts
+var GlobalSearchDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "GlobalSearch" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "query" }
+          },
+          type: {
+            kind: "NonNullType",
+            type: {
+              kind: "NamedType",
+              name: { kind: "Name", value: "String" }
+            }
+          }
+        },
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "limit" }
+          },
+          type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+        },
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "modelKeys" }
+          },
+          type: {
+            kind: "ListType",
+            type: {
+              kind: "NonNullType",
+              type: {
+                kind: "NamedType",
+                name: { kind: "Name", value: "String" }
+              }
+            }
+          }
+        },
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "includeMedia" }
+          },
+          type: { kind: "NamedType", name: { kind: "Name", value: "Boolean" } }
+        }
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "globalSearch" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "query" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "query" }
+                }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "limit" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "limit" }
+                }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "modelKeys" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "modelKeys" }
+                }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "includeMedia" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "includeMedia" }
+                }
+              }
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "records" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "modelKey" }
+                      },
+                      { kind: "Field", name: { kind: "Name", value: "title" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "naturalKey" }
+                      },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "subtitle" }
+                      },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "updatedAt" }
+                      }
+                    ]
+                  }
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "media" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "fileName" }
+                      },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "altText" }
+                      },
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "fileUrl" }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
 // src/commands/search.ts
 function registerSearchCommands(program2, globalOpts) {
   program2.command("search <query>").description("Search across all records and media").option(
@@ -3122,9 +1703,9 @@ Media (${data.globalSearch.media.length}):`);
 
 // src/commands/init.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve3, join as join4 } from "path";
-import chalk6 from "chalk";
+import { writeFile } from "fs/promises";
+import { resolve as resolve2, join as join4 } from "path";
+import chalk5 from "chalk";
 import inquirer3 from "inquirer";
 var FIELD_DEFAULTS = {
   text: "",
@@ -3214,18 +1795,18 @@ function registerInitCommands(program2, globalOpts) {
       async (key, opts) => {
         const globalFlags = globalOpts();
         const template = generateModelTemplate(key);
-        const outDir = resolve3(opts.output);
+        const outDir = resolve2(opts.output);
         if (!existsSync3(outDir)) {
           mkdirSync2(outDir, { recursive: true });
         }
         const ext = opts.ts ? "ts" : "json";
         const filePath = join4(outDir, `${key}.${ext}`);
         const content = opts.ts ? formatAsTypeScript(template) : JSON.stringify(template, null, 2) + "\n";
-        await writeFile2(filePath, content, "utf-8");
+        await writeFile(filePath, content, "utf-8");
         if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
           success(`Created ${filePath}`);
           console.log(
-            chalk6.gray(
+            chalk5.gray(
               `
 Edit the file, then run:
   foir models create -f ${filePath}`
@@ -3251,7 +1832,7 @@ Edit the file, then run:
         const models = result.models.items;
         if (models.length === 0) {
           console.log(
-            chalk6.yellow(
+            chalk5.yellow(
               "No models found. Create models first with `foir models create`."
             )
           );
@@ -3264,7 +1845,7 @@ Edit the file, then run:
             const found = models.find((m) => m.key === key);
             if (!found) {
               console.error(
-                chalk6.red(`Model "${key}" not found.`),
+                chalk5.red(`Model "${key}" not found.`),
                 "Available:",
                 models.map((m) => m.key).join(", ")
               );
@@ -3292,7 +1873,7 @@ Edit the file, then run:
           console.log("No models selected.");
           return;
         }
-        const outDir = resolve3(opts.output);
+        const outDir = resolve2(opts.output);
         if (!existsSync3(outDir)) {
           mkdirSync2(outDir, { recursive: true });
         }
@@ -3302,7 +1883,7 @@ Edit the file, then run:
           const ext = opts.ts ? "ts" : "json";
           const filePath = join4(outDir, `${model.key}.${ext}`);
           const content = opts.ts ? formatAsTypeScript(seed) : JSON.stringify(seed, null, 2) + "\n";
-          await writeFile2(filePath, content, "utf-8");
+          await writeFile(filePath, content, "utf-8");
           createdFiles.push(filePath);
           if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
             success(`Created ${filePath}`);
@@ -3310,7 +1891,7 @@ Edit the file, then run:
         }
         if (!(globalFlags.json || globalFlags.jsonl || globalFlags.quiet)) {
           console.log(
-            chalk6.gray(
+            chalk5.gray(
               `
 Edit the files, then run:
   foir records create --dir ${outDir} --publish`
@@ -3324,18 +1905,17 @@ Edit the files, then run:
   );
 }
 
-// src/commands/profiles.ts
-import chalk7 from "chalk";
-
-// src/lib/input.ts
-import inquirer4 from "inquirer";
+// src/commands/push.ts
+import chalk6 from "chalk";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
 
 // src/lib/config-loader.ts
 import { readFile } from "fs/promises";
 import { pathToFileURL } from "url";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 async function loadConfig(filePath) {
-  const absPath = resolve4(filePath);
+  const absPath = resolve3(filePath);
   if (filePath.endsWith(".ts")) {
     const configModule = await import(pathToFileURL(absPath).href);
     return configModule.default;
@@ -3353,7 +1933,194 @@ async function loadConfig(filePath) {
   );
 }
 
+// src/commands/push.ts
+var CONFIG_FILE_NAMES = [
+  "foir.config.ts",
+  "foir.config.js",
+  "foir.config.mjs",
+  "foir.config.json"
+];
+var APPLY_CONFIG_MUTATION = (
+  /* GraphQL */
+  `
+  mutation ApplyConfig($input: ApplyConfigInput!) {
+    applyConfig(input: $input) {
+      configId
+      configKey
+      credentials {
+        platformApiKey
+        platformEditorKey
+        webhookSecret
+      }
+      modelsCreated
+      modelsUpdated
+      operationsCreated
+      operationsUpdated
+      segmentsCreated
+      segmentsUpdated
+      schedulesCreated
+      schedulesUpdated
+      hooksCreated
+      hooksUpdated
+      isUpdate
+    }
+  }
+`
+);
+function discoverConfigFile() {
+  for (const name of CONFIG_FILE_NAMES) {
+    const path3 = resolve4(process.cwd(), name);
+    if (existsSync4(path3)) return path3;
+  }
+  return null;
+}
+function registerPushCommand(program2, globalOpts) {
+  program2.command("push").description("Push foir.config.ts to the platform").option("--config <path>", "Path to config file (default: auto-discover)").option("--force", "Force reinstall (delete and recreate)", false).action(
+    withErrorHandler(
+      globalOpts,
+      async (opts) => {
+        const configPath = opts.config ? resolve4(opts.config) : discoverConfigFile();
+        if (!configPath) {
+          throw new Error(
+            "No config file found. Create a foir.config.ts or use --config <path>."
+          );
+        }
+        if (!existsSync4(configPath)) {
+          throw new Error(`Config file not found: ${configPath}`);
+        }
+        console.log(chalk6.dim(`Loading ${configPath}...`));
+        const config2 = await loadConfig(configPath);
+        if (!config2?.key || !config2?.name) {
+          throw new Error(
+            'Config must have at least "key" and "name" fields.'
+          );
+        }
+        if (opts.force) {
+          config2.force = true;
+        }
+        const client = await createClient(globalOpts());
+        console.log(
+          chalk6.dim(`Pushing config "${config2.key}" to platform...`)
+        );
+        const data = await client.request(
+          APPLY_CONFIG_MUTATION,
+          { input: config2 }
+        );
+        const result = data.applyConfig;
+        console.log();
+        if (result.isUpdate) {
+          console.log(chalk6.green("Config updated successfully."));
+        } else {
+          console.log(chalk6.green("Config applied successfully."));
+        }
+        console.log();
+        console.log(`  Config ID:  ${chalk6.cyan(result.configId)}`);
+        console.log(`  Config Key: ${chalk6.cyan(result.configKey)}`);
+        console.log();
+        const stats = [
+          ["Models", result.modelsCreated, result.modelsUpdated],
+          ["Operations", result.operationsCreated, result.operationsUpdated],
+          ["Segments", result.segmentsCreated, result.segmentsUpdated],
+          ["Schedules", result.schedulesCreated, result.schedulesUpdated],
+          ["Hooks", result.hooksCreated, result.hooksUpdated]
+        ].filter(([, c, u]) => c > 0 || u > 0);
+        if (stats.length > 0) {
+          for (const [label, created, updated] of stats) {
+            const parts = [];
+            if (created > 0)
+              parts.push(chalk6.green(`${created} created`));
+            if (updated > 0)
+              parts.push(chalk6.yellow(`${updated} updated`));
+            console.log(`  ${label}: ${parts.join(", ")}`);
+          }
+          console.log();
+        }
+        if (result.credentials) {
+          console.log(chalk6.bold.yellow("Credentials (save these now):"));
+          console.log();
+          console.log(
+            `  PLATFORM_API_KEY:    ${chalk6.cyan(result.credentials.platformApiKey)}`
+          );
+          console.log(
+            `  PLATFORM_EDITOR_KEY: ${chalk6.cyan(result.credentials.platformEditorKey)}`
+          );
+          console.log(
+            `  WEBHOOK_SECRET:      ${chalk6.cyan(result.credentials.webhookSecret)}`
+          );
+          console.log();
+          console.log(
+            chalk6.dim(
+              "These credentials are only shown once. Store them securely."
+            )
+          );
+        }
+      }
+    )
+  );
+}
+
+// src/commands/remove.ts
+import chalk7 from "chalk";
+import inquirer4 from "inquirer";
+var GET_CONFIG_QUERY = (
+  /* GraphQL */
+  `
+  query GetConfigByKey($key: String!) {
+    configByKey(key: $key) {
+      id
+      key
+      name
+      configType
+    }
+  }
+`
+);
+var UNREGISTER_MUTATION = (
+  /* GraphQL */
+  `
+  mutation UnregisterConfig($id: ID!) {
+    unregisterConfig(id: $id)
+  }
+`
+);
+function registerRemoveCommand(program2, globalOpts) {
+  program2.command("remove <key>").description("Remove a config and all its provisioned resources").option("--force", "Skip confirmation prompt", false).action(
+    withErrorHandler(
+      globalOpts,
+      async (key, opts) => {
+        const client = await createClient(globalOpts());
+        const { configByKey: config2 } = await client.request(GET_CONFIG_QUERY, { key });
+        if (!config2) {
+          throw new Error(`Config not found: ${key}`);
+        }
+        if (!opts.force) {
+          const { confirmed } = await inquirer4.prompt([
+            {
+              type: "confirm",
+              name: "confirmed",
+              message: `Remove config "${config2.name}" (${config2.key})? This will delete all its models, operations, hooks, and schedules.`,
+              default: false
+            }
+          ]);
+          if (!confirmed) {
+            console.log(chalk7.dim("Cancelled."));
+            return;
+          }
+        }
+        await client.request(UNREGISTER_MUTATION, { id: config2.id });
+        console.log(
+          chalk7.green(`Removed config "${config2.name}" (${config2.key}).`)
+        );
+      }
+    )
+  );
+}
+
+// src/commands/profiles.ts
+import chalk8 from "chalk";
+
 // src/lib/input.ts
+import inquirer5 from "inquirer";
 async function parseInputData(opts) {
   if (opts.data) {
     return JSON.parse(opts.data);
@@ -3382,7 +2149,7 @@ function isUUID(value) {
 }
 async function confirmAction(message, opts) {
   if (opts?.confirm) return true;
-  const { confirmed } = await inquirer4.prompt([
+  const { confirmed } = await inquirer5.prompt([
     {
       type: "confirm",
       name: "confirmed",
@@ -3553,7 +2320,7 @@ function registerProfilesCommand(program2, globalOpts) {
         if (opts.json || opts.jsonl) {
           formatOutput({ deleted: name }, opts);
         } else {
-          console.log(chalk7.green(`Deleted profile "${name}".`));
+          console.log(chalk8.green(`Deleted profile "${name}".`));
         }
       }
     )
@@ -3562,9 +2329,9 @@ function registerProfilesCommand(program2, globalOpts) {
 
 // src/commands/register-commands.ts
 import { readFileSync, readdirSync } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { resolve as resolve5, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // ../command-registry/src/command-map.ts
 var COMMANDS = [
@@ -4190,65 +2957,65 @@ var COMMANDS = [
   // EXTENSIONS
   // =========================================================================
   {
-    group: "extensions",
+    group: "configs",
     name: "list",
-    description: "List extensions",
-    operation: "extensions",
+    description: "List configs",
+    operation: "configs",
     operationType: "query",
     columns: [
       { key: "id", header: "ID", width: 28 },
       { key: "key", header: "Key", width: 20 },
       { key: "name", header: "Name", width: 20 },
-      { key: "extensionType", header: "Type", width: 12 },
+      { key: "configType", header: "Type", width: 12 },
       { key: "enabled", header: "Enabled", width: 8, format: "boolean" },
       { key: "syncStatus", header: "Sync", width: 10 }
     ]
   },
   {
-    group: "extensions",
+    group: "configs",
     name: "get",
-    description: "Get an extension",
-    operation: "extension",
+    description: "Get a config",
+    operation: "config",
     operationType: "query",
     positionalArgs: [{ name: "id", graphqlArg: "id" }],
-    alternateGet: { operation: "extensionByKey", argName: "key" }
+    alternateGet: { operation: "configByKey", argName: "key" }
   },
   {
-    group: "extensions",
+    group: "configs",
     name: "register",
-    description: "Register an extension",
-    operation: "registerExtension",
+    description: "Register a config",
+    operation: "registerConfig",
     operationType: "mutation",
     acceptsInput: true,
-    successMessage: "Registered extension"
+    successMessage: "Registered config"
   },
   {
-    group: "extensions",
-    name: "install",
-    description: "Install an extension",
-    operation: "installExtension",
+    group: "configs",
+    name: "apply",
+    description: "Apply a config",
+    operation: "applyConfig",
     operationType: "mutation",
     acceptsInput: true,
-    successMessage: "Installed extension"
+    successMessage: "Applied config"
   },
   {
-    group: "extensions",
+    group: "configs",
     name: "uninstall",
-    description: "Unregister an extension",
-    operation: "unregisterExtension",
+    description: "Unregister a config",
+    operation: "unregisterConfig",
     operationType: "mutation",
     positionalArgs: [{ name: "id", graphqlArg: "id" }],
     requiresConfirmation: true,
     scalarResult: true,
-    successMessage: "Unregistered extension"
+    successMessage: "Unregistered config"
   },
   {
-    group: "extensions",
+    group: "configs",
     name: "sync",
-    description: "Trigger extension sync",
-    operation: "triggerExtensionSync",
+    description: "Trigger config sync",
+    operation: "triggerConfigSync",
     operationType: "mutation",
-    positionalArgs: [{ name: "extensionId", graphqlArg: "extensionId" }],
+    positionalArgs: [{ name: "configId", graphqlArg: "configId" }],
     successMessage: "Triggered sync"
   },
   // =========================================================================
@@ -5163,7 +3930,7 @@ function createSchemaEngine(sdl) {
 
 // src/commands/register-commands.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname5(__filename);
+var __dirname = dirname4(__filename);
 function loadSchemaSDL() {
   const bundledPath = resolve5(__dirname, "schema.graphql");
   try {
@@ -5329,7 +4096,7 @@ function registerDynamicCommands(program2, globalOpts) {
             const files = readdirSync(dirPath).filter((f) => /\.(json|ts|js|mjs)$/.test(f)).sort();
             if (files.length === 0) {
               console.error(
-                chalk8.yellow(`\u26A0 No .json/.ts/.js files found in ${dirPath}`)
+                chalk9.yellow(`\u26A0 No .json/.ts/.js files found in ${dirPath}`)
               );
               return;
             }
@@ -5374,19 +4141,19 @@ function registerDynamicCommands(program2, globalOpts) {
                   } catch (updateErr) {
                     failed++;
                     const msg2 = updateErr instanceof Error ? updateErr.message : String(updateErr);
-                    console.error(chalk8.red(`\u2717 ${label}:`), msg2);
+                    console.error(chalk9.red(`\u2717 ${label}:`), msg2);
                     continue;
                   }
                 }
                 failed++;
                 const msg = err instanceof Error ? err.message : String(err);
-                console.error(chalk8.red(`\u2717 ${label}:`), msg);
+                console.error(chalk9.red(`\u2717 ${label}:`), msg);
               }
             }
             if (!(opts.json || opts.jsonl || opts.quiet)) {
               console.log("");
               console.log(
-                chalk8.bold(
+                chalk9.bold(
                   `Done: ${created} created${updated ? `, ${updated} updated` : ""}${failed ? `, ${failed} failed` : ""}`
                 )
               );
@@ -5562,7 +4329,7 @@ function registerDynamicCommands(program2, globalOpts) {
               }
             } else if (!(opts.json || opts.jsonl || opts.quiet)) {
               console.error(
-                chalk8.yellow(
+                chalk9.yellow(
                   "\u26A0 Could not auto-publish: no version found in response"
                 )
               );
@@ -5585,7 +4352,7 @@ function autoColumns(items) {
 
 // src/cli.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname6(__filename2);
+var __dirname2 = dirname5(__filename2);
 config({ path: resolve6(__dirname2, "../.env.local") });
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -5608,8 +4375,9 @@ registerWhoamiCommand(program, getGlobalOpts);
 registerProfilesCommand(program, getGlobalOpts);
 registerMediaCommands(program, getGlobalOpts);
 registerSearchCommands(program, getGlobalOpts);
-registerPullCommand(program, getGlobalOpts);
-registerCreateExtensionCommand(program, getGlobalOpts);
+registerPushCommand(program, getGlobalOpts);
+registerRemoveCommand(program, getGlobalOpts);
+registerCreateConfigCommand(program, getGlobalOpts);
 registerInitCommands(program, getGlobalOpts);
 registerDynamicCommands(program, getGlobalOpts);
 program.parse();