@svgrid/enterprise 2.5.2 → 2.6.0

package/src/studio/scaffold.test.ts

@@ -1,192 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { compile } from 'svelte/compiler'
-import type { EntitySchema } from '../schema'
-import { MANAGED_END, MANAGED_START, mergeManaged, scaffold, skipUserOwned } from './scaffold'
-
-const schema: EntitySchema = {
-  name: 'customers',
-  label: 'Customer',
-  idField: 'id',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true, readonly: true },
-    { field: 'firstName', type: 'text', required: true },
-    { field: 'age', type: 'number' },
-    { field: 'tier', type: 'enum', options: [{ value: 'free', label: 'Free' }] },
-  ],
-}
-
-describe('scaffold', () => {
-  const { files } = scaffold(schema)
-  const byPath = Object.fromEntries(files.map((f) => [f.path, f]))
-
-  it('emits schema, server route, and page files at SvelteKit paths', () => {
-    expect(Object.keys(byPath).sort()).toEqual([
-      'src/lib/customers.schema.ts',
-      'src/routes/api/customers/+server.ts',
-      'src/routes/customers/+page.svelte',
-    ])
-  })
-
-  it('the schema file exports a typed EntitySchema literal and Row type', () => {
-    const c = byPath['src/lib/customers.schema.ts']!.contents
-    expect(c).toContain('export const customersSchema: EntitySchema<CustomersRow>')
-    expect(c).toContain('export type CustomersRow = {')
-    expect(c).toContain('age: number')
-    expect(c).toContain('firstName: string')
-    expect(c).toContain(`field: "tier", type: "enum"`)
-    expect(c).toContain(`options: [{"value":"free","label":"Free"}]`)
-  })
-
-  it('the server route wires createKitHandlers', () => {
-    const c = byPath['src/routes/api/customers/+server.ts']!.contents
-    expect(c).toContain('createKitHandlers({ schema: customersSchema, source })')
-    expect(c).toContain('export const { POST }')
-  })
-
-  it('the page wires the grid + edit panel over the transport', () => {
-    const c = byPath['src/routes/customers/+page.svelte']!.contents
-    expect(c).toContain("createKitDataSource<CustomersRow>({ endpoint: '/api/customers' })")
-    expect(c).toContain('schemaToColumns(customersSchema)')
-    expect(c).toContain('<SvGrid')
-    expect(c).toContain('<SvGridEditPanel')
-  })
-
-  it('the page is a full data screen: sort, filter, paging, delete, optimistic', () => {
-    const c = byPath['src/routes/customers/+page.svelte']!.contents
-    expect(c).toContain('sortable')
-    expect(c).toContain('externalSort')
-    expect(c).toContain('controller.setSort(s)')
-    expect(c).toContain('filterable')
-    expect(c).toContain('showGlobalFilter')
-    expect(c).toContain('controller.setFilter(') // server filtering
-    expect(c).toContain('fitColumns') // columns fill the width
-    expect(c).toContain('enableRowSummaries={false}') // no default summary
-    expect(c).toContain('externalPagination') // native server pagination footer
-    expect(c).toContain('onPaginationChange')
-    expect(c).toContain('controller.setPage(') // pagination
-    expect(c).toContain('removeSelected') // multi-select delete
-    expect(c).toContain('optimistic: true')
-    expect(c).toContain("getRowId: (r) => String(r.id)") // uses the primary key
-    expect(c).toContain('role="alert"') // error state
-    expect(c).toContain('emptyMessage=') // empty state
-  })
-
-  it('the generated page is syntactically valid Svelte (compiles)', () => {
-    // Compile with Svelte's own compiler - validates markup, runes, bindings,
-    // and snippets. (It does not resolve imports; that's the bundler's job.)
-    const page = byPath['src/routes/customers/+page.svelte']!.contents
-    expect(() => compile(page, { filename: '+page.svelte', generate: 'client' })).not.toThrow()
-  })
-
-  it('wraps every file body in managed markers', () => {
-    for (const f of files) {
-      expect(f.contents).toContain(MANAGED_START)
-      expect(f.contents).toContain(MANAGED_END)
-    }
-  })
-
-  it('emits a connected +server.ts for a database dialect', () => {
-    const pg = scaffold(schema, { dataSource: 'postgres' }).files.find(
-      (f) => f.path === 'src/routes/api/customers/+server.ts',
-    )!.contents
-    expect(pg).toContain("import pg from 'pg'")
-    expect(pg).toContain('new pg.Pool({ connectionString: process.env.DATABASE_URL })')
-    expect(pg).toContain('createSqlDataSource')
-    expect(pg).toContain("placeholders: '$'")
-    expect(pg).toContain('await pool.query(text, params)')
-
-    const sqlite = scaffold(schema, { dataSource: 'sqlite' }).files.find((f) =>
-      f.path.endsWith('+server.ts'),
-    )!.contents
-    expect(sqlite).toContain("import Database from 'better-sqlite3'")
-    expect(sqlite).toContain('db.prepare(text).all(...params)')
-
-    const mssql = scaffold(schema, { dataSource: 'mssql' }).files.find((f) =>
-      f.path.endsWith('+server.ts'),
-    )!.contents
-    expect(mssql).toContain("import mssql from 'mssql'")
-    expect(mssql).toContain("placeholders: '@'")
-
-    // supabase reuses the postgres driver
-    const supa = scaffold(schema, { dataSource: 'supabase' }).files.find((f) =>
-      f.path.endsWith('+server.ts'),
-    )!.contents
-    expect(supa).toContain("import pg from 'pg'")
-  })
-
-  it('honors route/apiRoute overrides', () => {
-    const { files: f2 } = scaffold(schema, { route: 'clients', apiRoute: '/data/clients' })
-    const paths = f2.map((x) => x.path)
-    expect(paths).toContain('src/routes/clients/+page.svelte')
-    expect(paths).toContain('src/routes/data/clients/+server.ts')
-  })
-
-  it('the base page (no relations) has no lookup wiring', () => {
-    const c = byPath['src/routes/customers/+page.svelte']!.contents
-    expect(c).not.toContain('createRelationLookup')
-    expect(c).not.toContain('lookups={lookups}')
-  })
-})
-
-describe('scaffold with relation fields', () => {
-  const relSchema: EntitySchema = {
-    name: 'contacts',
-    label: 'Contact',
-    idField: 'id',
-    fields: [
-      { field: 'id', type: 'number', primaryKey: true, readonly: true },
-      { field: 'name', type: 'text', required: true },
-      { field: 'companyId', type: 'relation', label: 'Company', relation: { entity: 'companies', foreignKey: 'companyId', labelField: 'name' } },
-    ],
-  }
-  const page = scaffold(relSchema).files.find((f) => f.path === 'src/routes/contacts/+page.svelte')!.contents
-
-  it('generates a lookup over the related API route and wires it into the edit panel', () => {
-    expect(page).toContain('createRelationLookup')
-    expect(page).toContain('createKitDataSource({ endpoint: "/api/companies" })')
-    expect(page).toContain('labelField: "name"')
-    expect(page).toContain('const lookups = { "companyId": companyIdLookup }')
-    expect(page).toContain('lookups={lookups}')
-  })
-
-  it('the page with lookups is valid Svelte (compiles)', () => {
-    expect(() => compile(page, { filename: '+page.svelte', generate: 'client' })).not.toThrow()
-  })
-})
-
-describe('mergeManaged', () => {
-  it('uses the generated file whole when there is no existing content', () => {
-    const gen = `head\n${MANAGED_START}\nX\n${MANAGED_END}\ntail`
-    expect(mergeManaged(null, gen)).toBe(gen)
-  })
-
-  it('replaces only the managed region, preserving user edits outside', () => {
-    const existing = `import x\n${MANAGED_START}\nOLD\n${MANAGED_END}\n// my custom helper\nconst keep = 1`
-    const generated = `import y\n${MANAGED_START}\nNEW\n${MANAGED_END}\nignored tail`
-    const merged = mergeManaged(existing, generated)
-    expect(merged).toContain('import x') // user's import kept
-    expect(merged).toContain('// my custom helper') // user's code kept
-    expect(merged).toContain('const keep = 1')
-    expect(merged).toContain('NEW') // managed region updated
-    expect(merged).not.toContain('OLD')
-    expect(merged).not.toContain('ignored tail')
-  })
-
-  it('falls back to generated when existing has no markers', () => {
-    expect(mergeManaged('no markers here', 'GEN')).toBe('GEN')
-  })
-})
-
-describe('skipUserOwned (the handlers.ts write-once contract)', () => {
-  it('skips a user-owned file that already exists on disk (never clobber user code)', () => {
-    expect(skipUserOwned({ userOwned: true }, true)).toBe(true)
-  })
-  it('writes a user-owned file when it does not exist yet (scaffold the stub once)', () => {
-    expect(skipUserOwned({ userOwned: true }, false)).toBe(false)
-  })
-  it('always writes a generated (non-user-owned) file, whether or not it exists', () => {
-    expect(skipUserOwned({ userOwned: false }, true)).toBe(false)
-    expect(skipUserOwned({}, true)).toBe(false)
-    expect(skipUserOwned({ userOwned: undefined }, true)).toBe(false)
-  })
-})

package/src/studio/scaffold.ts

@@ -1,390 +0,0 @@
-/**
- * scaffold - turn an `EntitySchema` into runnable SvelteKit files. The shared
- * code-emit core: both the AI generator (MCP `scaffold_entity` tool) and the
- * visual designer's "Generate code" action call this one function, so there is
- * a single source of truth for what generated code looks like.
- *
- * Every generated file wraps its body in `svgrid:managed` markers. A future
- * regeneration replaces only the managed region, so edits a user makes outside
- * the markers survive - idempotent generation, the thing that makes a
- * generator trustworthy enough to keep using.
- *
- * Pure string building. No filesystem, no Svelte. The `validate` (Standard
- * Schema) functions on a field cannot be serialized to a literal, so they are
- * omitted from the emitted schema with a note to re-add them by hand.
- */
-import { resolveIdField, type EntityField, type EntitySchema } from '../schema.js'
-import type { SqlDialectName } from './introspect-db.js'
-
-export type GeneratedFile = {
-  path: string
-  contents: string
-  description: string
-  /** A user-owned companion (e.g. a screen's `handlers.ts`): scaffolded once as a
-   *  starting stub, then never overwritten. In-place writers must skip it if it
-   *  already exists. See HANDLERS-DESIGN.md. */
-  userOwned?: boolean
-}
-
-export type ScaffoldOptions = {
-  /** Route segment for the page, defaults to the schema name. e.g. `'customers'`. */
-  route?: string
-  /** API route the page talks to, defaults to `/api/{route}`. */
-  apiRoute?: string
-  /** `$lib` path for the generated schema module, defaults to `$lib/{route}.schema`. */
-  schemaImport?: string
-  /**
-   * Backend the generated API route uses:
-   *   - `'memory'` (default): `createInMemoryDataSource` - runs immediately, no DB.
-   *   - `'sql'`: `createSqlDataSource` with an `execute(text, params)` stub you fill in.
-   *   - a dialect (`'postgres'` | `'supabase'` | `'mysql'` | `'mssql'` | `'sqlite'`):
-   *     a fully-connected route wired to that driver via `process.env.DATABASE_URL`.
-   */
-  dataSource?: 'memory' | 'sql' | SqlDialectName
-}
-
-/** Per-dialect driver wiring for a connected `+server.ts`. */
-type DriverWiring = { imports: string; setup: string; dialectArg: string; execBody: string }
-const DRIVERS: Record<'postgres' | 'mysql' | 'mssql' | 'sqlite', DriverWiring> = {
-  postgres: {
-    imports: `import pg from 'pg'`,
-    setup: `const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })`,
-    dialectArg: `\n  dialect: { placeholders: '$', ilike: true },`,
-    execBody: `const result = await pool.query(text, params)\n    return result.rows`,
-  },
-  mysql: {
-    imports: `import mysql from 'mysql2/promise'`,
-    setup: `const pool = mysql.createPool(process.env.DATABASE_URL ?? '')`,
-    dialectArg: ``,
-    execBody: `const [rows] = await pool.query(text, params)\n    return rows as Record<string, unknown>[]`,
-  },
-  mssql: {
-    imports: `import mssql from 'mssql'`,
-    setup: `const poolPromise = mssql.connect(process.env.DATABASE_URL ?? '')`,
-    dialectArg: `\n  dialect: { placeholders: '@' },`,
-    execBody: `const pool = await poolPromise\n    const request = pool.request()\n    params.forEach((p, i) => request.input('p' + (i + 1), p))\n    const result = await request.query(text)\n    return result.recordset as Record<string, unknown>[]`,
-  },
-  sqlite: {
-    imports: `import Database from 'better-sqlite3'`,
-    setup: `const db = new Database(process.env.DATABASE_URL ?? 'data.db')`,
-    dialectArg: ``,
-    execBody: `return db.prepare(text).all(...params) as Record<string, unknown>[]`,
-  },
-}
-
-/**
- * Whether an in-place writer must SKIP this file to preserve the developer's
- * code: a user-owned companion (a screen's `handlers.ts`) that already exists on
- * disk. Such files carry no `svgrid:managed` markers, so `mergeManaged` would
- * overwrite them wholesale - the write-once contract lives here instead, shared
- * by every writer (CLI regenerate + the designer's bundle write). See
- * HANDLERS-DESIGN.md.
- */
-export function skipUserOwned(file: Pick<GeneratedFile, 'userOwned'>, existsOnDisk: boolean): boolean {
-  return file.userOwned === true && existsOnDisk
-}
-
-export const MANAGED_START = '// svgrid:managed:start'
-export const MANAGED_END = '// svgrid:managed:end'
-const MANAGED_NOTE = '// Regenerated by SvGrid Studio. Edits inside these markers are overwritten.'
-
-function pascal(name: string): string {
-  return name
-    .replace(/[_\-\s]+/g, ' ')
-    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
-    .split(' ')
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-    .join('')
-}
-
-function camel(name: string): string {
-  const p = pascal(name)
-  return p.charAt(0).toLowerCase() + p.slice(1)
-}
-
-function tsType(field: EntityField): string {
-  switch (field.type) {
-    case 'number':
-      return 'number'
-    case 'boolean':
-      return 'boolean'
-    default:
-      return 'string'
-  }
-}
-
-function fieldLiteral(field: EntityField): string {
-  const parts = [`field: ${JSON.stringify(field.field)}`, `type: ${JSON.stringify(field.type)}`]
-  if (field.label) parts.push(`label: ${JSON.stringify(field.label)}`)
-  if (field.primaryKey) parts.push('primaryKey: true')
-  if (field.readonly) parts.push('readonly: true')
-  if (field.required) parts.push('required: true')
-  if (field.hidden) parts.push(`hidden: ${JSON.stringify(field.hidden)}`)
-  if (field.options) parts.push(`options: ${JSON.stringify(field.options)}`)
-  if (field.relation) parts.push(`relation: ${JSON.stringify(field.relation)}`)
-  return `    { ${parts.join(', ')} }`
-}
-
-function schemaLiteral(schema: EntitySchema, constName: string, rowType: string): string {
-  const head = [`  name: ${JSON.stringify(schema.name)}`]
-  if (schema.label) head.push(`  label: ${JSON.stringify(schema.label)}`)
-  if (schema.idField) head.push(`  idField: ${JSON.stringify(schema.idField)}`)
-  const fields = schema.fields.map(fieldLiteral).join(',\n')
-  return `export const ${constName}: EntitySchema<${rowType}> = {\n${head.join(',\n')},\n  fields: [\n${fields}\n  ],\n}`
-}
-
-function managed(body: string): string {
-  return `${MANAGED_START}\n${MANAGED_NOTE}\n${body}\n${MANAGED_END}`
-}
-
-export function scaffold(schema: EntitySchema, options: ScaffoldOptions = {}): { files: GeneratedFile[] } {
-  const route = options.route ?? schema.name
-  const apiRoute = options.apiRoute ?? `/api/${route}`
-  const schemaImport = options.schemaImport ?? `$lib/${route}.schema`
-  const constName = `${camel(schema.name)}Schema`
-  const rowType = `${pascal(schema.name)}Row`
-  const idField = resolveIdField(schema)
-  const label = schema.label ?? schema.name
-
-  const rowFields = schema.fields
-    .map((f) => `  ${f.field}: ${tsType(f)}`)
-    .join('\n')
-
-  // 1. The schema module ($lib).
-  const schemaFile: GeneratedFile = {
-    path: `src/lib/${route}.schema.ts`,
-    description: 'Entity schema + row type. Re-add any Standard Schema `validate` functions here by hand.',
-    contents: `import type { EntitySchema } from '@svgrid/enterprise'
-
-${managed(`export type ${rowType} = {
-${rowFields}
-}
-
-${schemaLiteral(schema, constName, rowType)}`)}
-`,
-  }
-
-  // 2. The API route: SvelteKit +server.ts using the transport handlers.
-  const dataSource = options.dataSource ?? 'memory'
-  const driver = dataSource === 'supabase' ? DRIVERS.postgres : DRIVERS[dataSource as 'postgres']
-  let serverImport: string
-  let serverBody: string
-  let serverDescription: string
-
-  if (driver) {
-    // Fully-connected route: driver + DATABASE_URL, no manual editing needed.
-    serverImport = `${driver.imports}
-import { createKitHandlers, createSqlDataSource } from '@svgrid/enterprise'`
-    serverBody = `${driver.setup}
-
-const source = createSqlDataSource<${rowType}>({
-  schema: ${constName},
-  table: ${JSON.stringify(schema.name)},${driver.dialectArg}
-  execute: async (text, params) => {
-    ${driver.execBody}
-  },
-})
-
-export const { POST } = createKitHandlers({ schema: ${constName}, source })`
-    serverDescription = `API route connected to your ${dataSource} database via process.env.DATABASE_URL.`
-  } else if (dataSource === 'sql') {
-    serverImport = `import { createKitHandlers, createSqlDataSource } from '@svgrid/enterprise'`
-    serverBody = `// Wire execute() to your SQL client: run \`text\` with \`params\`, return the rows.
-// Works with Drizzle (db.execute), postgres.js, better-sqlite3, mysql2, ...
-const source = createSqlDataSource<${rowType}>({
-  schema: ${constName},
-  table: ${JSON.stringify(schema.name)},
-  dialect: { placeholders: '$', ilike: true },
-  execute: async (text, params) => {
-    throw new Error('TODO: run the query with your database client and return the rows.')
-  },
-})
-
-export const { POST } = createKitHandlers({ schema: ${constName}, source })`
-    serverDescription = 'API route. Fill in execute() with your SQL client (Drizzle / postgres.js / ...).'
-  } else {
-    serverImport = `import { createInMemoryDataSource, createKitHandlers } from '@svgrid/enterprise'`
-    serverBody = `// Starts empty and in-memory so the screen runs immediately. Swap this for
-// a database-backed source (scaffold with dataSource:"sql" or a dialect) when ready.
-const source = createInMemoryDataSource<${rowType}>([], ${constName})
-
-export const { POST } = createKitHandlers({ schema: ${constName}, source })`
-    serverDescription = 'API route using an in-memory source. Scaffold with a dialect for a real database.'
-  }
-
-  const serverFile: GeneratedFile = {
-    path: `src/routes${apiRoute}/+server.ts`,
-    description: serverDescription,
-    contents: `${serverImport}
-import { ${constName}, type ${rowType} } from '${schemaImport}'
-
-${managed(serverBody)}
-`,
-  }
-
-  // Relation (foreign-key) fields become searchable lookups in the edit form.
-  // Each lookup queries the related entity's API route, so scaffold those tables
-  // too (e.g. `npx @svgrid/studio add <relatedTable>`).
-  const relationFields = schema.fields.filter(
-    (f): f is EntityField & { relation: NonNullable<EntityField['relation']> } =>
-      f.type === 'relation' && !!f.relation,
-  )
-  const hasLookups = relationFields.length > 0
-  const lookupDecls = relationFields
-    .map((f) => {
-      const name = `${camel(f.field)}Lookup`
-      const endpoint = JSON.stringify(`/api/${f.relation.entity}`)
-      return `  const ${name} = createRelationLookup<Record<string, unknown>>({
-    source: createKitDataSource({ endpoint: ${endpoint} }),
-    labelField: ${JSON.stringify(f.relation.labelField)},
-  })`
-    })
-    .join('\n')
-  const lookupsMap = `  const lookups = { ${relationFields
-    .map((f) => `${JSON.stringify(f.field)}: ${camel(f.field)}Lookup`)
-    .join(', ')} }`
-  const lookupsSection = hasLookups ? `\n\n${lookupDecls}\n${lookupsMap}` : ''
-
-  // 3. The page: a full data screen - search, server sort + paging,
-  //    multi-select delete (optimistic), create/edit, loading/error/empty.
-  const pageBody = `  const source = createKitDataSource<${rowType}>({ endpoint: '${apiRoute}' })
-  const columns = schemaToColumns(${constName})${lookupsSection}
-
-  let state = $state<ServerState<${rowType}>>({
-    rows: [], total: 0, loading: false, saving: false, error: null,
-    pageIndex: 0, pageSize: 25, pageCount: 1, sortModel: [], filterModel: {},
-  })
-  const controller = createServerDataSource<${rowType}>(source, {
-    pageSize: 25,
-    optimistic: true,
-    getRowId: (r) => String(r.${idField}),
-    onChange: (s) => (state = s),
-  })
-  controller.refresh()
-
-  let selected = $state<${rowType}[]>([])
-  let editing = $state<${rowType} | null | undefined>(undefined) // undefined = closed, null = create
-
-  async function save({ mode, id, values }: { mode: 'create' | 'edit'; id: string | null; values: Partial<${rowType}> }) {
-    if (mode === 'create') {
-      await controller.createRow(values)
-      controller.setPage(state.pageCount - 1) // jump to the new row (appended at the end)
-    } else if (id) {
-      await controller.updateRow(id, values)
-    }
-    editing = undefined
-  }
-
-  async function removeSelected() {
-    for (const row of selected) await controller.deleteRow(String(row.${idField}))
-    selected = []
-  }`
-
-  const pageFile: GeneratedFile = {
-    path: `src/routes/${route}/+page.svelte`,
-    description: 'The data screen: sort, filter, search, paging, multi-select delete, and create/edit - wired to the API route.',
-    contents: `<script lang="ts">
-  import { SvGrid, createServerDataSource } from '@svgrid/grid'
-  import {
-    SvGridEditPanel,
-    createKitDataSource,${hasLookups ? '\n    createRelationLookup,' : ''}
-    schemaToColumns,
-    type ServerState,
-  } from '@svgrid/enterprise'
-  import { ${constName}, type ${rowType} } from '${schemaImport}'
-
-${managed(pageBody)}
-</script>
-
-<div class="page">
-  <header class="page__toolbar">
-    <h2 class="page__title">${label}</h2>
-    <div class="page__actions">
-      <button onclick={() => (editing = null)}>New</button>
-      <button disabled={selected.length === 0} onclick={removeSelected}>
-        Delete {selected.length > 0 ? '(' + selected.length + ')' : ''}
-      </button>
-    </div>
-  </header>
-
-  {#if state.error}<p class="page__error" role="alert">{state.error}</p>{/if}
-
-  <SvGrid
-    data={state.rows}
-    {columns}
-    loading={state.loading}
-    loadingOverlay
-    fitColumns
-    enableRowSummaries={false}
-    showRowSelection
-    enableCellSelection
-    sortable
-    externalSort
-    onSortingChange={(s) => controller.setSort(s)}
-    filterable
-    showGlobalFilter
-    externalFilter
-    onFiltersChange={(f) =>
-      controller.setFilter({
-        global: f.global || undefined,
-        columns: Object.fromEntries(
-          f.columns.map((c) => [c.id, { operator: c.operator, value: c.value, valueTo: c.valueTo, selectedValues: c.selectedValues }]),
-        ),
-      })}
-    onRowClick={(e) => (editing = e.row)}
-    onRowSelectionChange={(_sel, rows) => (selected = rows)}
-    showPagination
-    externalPagination
-    rowCount={state.total}
-    pageIndex={state.pageIndex}
-    pageSize={state.pageSize}
-    onPaginationChange={({ pageIndex, pageSize }) => {
-      if (pageSize !== state.pageSize) controller.setPageSize(pageSize)
-      else controller.setPage(pageIndex)
-    }}
-    emptyMessage="No ${label} yet"
-    containerHeight={480}
-  />
-
-  {#if editing !== undefined}
-    <SvGridEditPanel schema={${constName}} row={editing} ${hasLookups ? 'lookups={lookups} ' : ''}onSubmit={save} onCancel={() => (editing = undefined)} />
-  {/if}
-</div>
-
-<style>
-  .page { display: flex; flex-direction: column; gap: 12px; }
-  .page__toolbar { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
-  .page__title { margin: 0; font-size: 18px; font-weight: 600; }
-  .page__actions { display: flex; gap: 8px; }
-  .page__actions button { padding: 7px 12px; border: 1px solid #ccc; border-radius: 6px; background: #fff; cursor: pointer; }
-  .page__error { margin: 0; padding: 8px 12px; color: #b3261e; background: #fdecea; border-radius: 6px; }
-</style>
-`,
-  }
-
-  return { files: [schemaFile, serverFile, pageFile] }
-}
-
-/**
- * Merge freshly-scaffolded files into existing file contents, replacing only
- * each file's `svgrid:managed` region and preserving everything a user wrote
- * outside it. When there's no existing content (or no markers in it), the new
- * file is used whole. This is what makes regeneration safe.
- */
-export function mergeManaged(existing: string | null | undefined, generated: string): string {
-  if (!existing) return generated
-
-  const startIdx = existing.indexOf(MANAGED_START)
-  const endIdx = existing.indexOf(MANAGED_END)
-  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return generated
-
-  const genStart = generated.indexOf(MANAGED_START)
-  const genEnd = generated.indexOf(MANAGED_END)
-  if (genStart === -1 || genEnd === -1) return generated
-  const newRegion = generated.slice(genStart, genEnd + MANAGED_END.length)
-
-  return (
-    existing.slice(0, startIdx) + newRegion + existing.slice(endIdx + MANAGED_END.length)
-  )
-}