@svgrid/enterprise 2.2.1 → 2.3.1

package/src/scheduler-resource-tree.ts

@@ -0,0 +1,107 @@
+/**
+ * scheduler-resource-tree - the pure core behind Scheduler Pro *grouped / tree
+ * resources*. No Svelte, no DOM. Resources are flat in the base grid; this builds
+ * a hierarchy of collapsible GROUP header rows (departments -> teams -> people)
+ * interleaved with the resource rows, so the timeline gutter can render a tree.
+ *
+ * Groups nest via `parentId`; each resource is mapped to a group by a `groupOf`
+ * accessor. Resources whose group is unknown / unset fall into a trailing
+ * "ungrouped" section (rendered without a header). Collapsing a group drops its
+ * whole subtree from the output (the header stays).
+ */
+
+/** A group node in the resource tree. `parentId` nests it under another group. */
+export type SchedulerResourceGroup = {
+  id: string
+  title: string
+  parentId?: string
+  color?: string
+}
+
+/** One rendered row: a group header, or a leaf resource. */
+export type ResourceRow<R = unknown> = {
+  kind: 'group' | 'resource'
+  id: string
+  title: string
+  /** Indent depth (0 = top level). */
+  depth: number
+  color?: string
+  /** Present for `kind: 'resource'`. */
+  resource?: R
+  /** Present for `kind: 'group'`: whether it is collapsed. */
+  collapsed?: boolean
+  /** Present for `kind: 'group'`: every leaf resource id in its subtree (for roll-ups). */
+  childResourceIds?: string[]
+}
+
+type MinResource = { id: string; title?: string; color?: string }
+
+/**
+ * Build the ordered tree rows. `groups` define the hierarchy; `groupOf(resource)`
+ * returns the group id a resource belongs to (or undefined = ungrouped). `collapsed`
+ * is the set of collapsed group ids. Order: for each group, its child groups
+ * (recursively) then its direct resources; ungrouped resources trail at the end.
+ */
+export function buildResourceRows<R extends MinResource>(
+  resources: ReadonlyArray<R>,
+  groups: ReadonlyArray<SchedulerResourceGroup>,
+  groupOf: (r: R) => string | undefined,
+  collapsed: ReadonlySet<string> = new Set(),
+): ResourceRow<R>[] {
+  const groupById = new Map<string, SchedulerResourceGroup>()
+  for (const g of groups) if (g && g.id) groupById.set(g.id, g)
+
+  // parentId -> child groups (root groups keyed under '' ). A parentId that is not
+  // a known group is treated as a root.
+  const childGroups = new Map<string, SchedulerResourceGroup[]>()
+  for (const g of groupById.values()) {
+    const p = g.parentId && groupById.has(g.parentId) ? g.parentId : ''
+    ;(childGroups.get(p) ?? childGroups.set(p, []).get(p)!).push(g)
+  }
+
+  // group id -> resources ('' = ungrouped / unknown group).
+  const resByGroup = new Map<string, R[]>()
+  for (const r of resources) {
+    const gid = groupOf(r)
+    const key = gid && groupById.has(gid) ? gid : ''
+    ;(resByGroup.get(key) ?? resByGroup.set(key, []).get(key)!).push(r)
+  }
+
+  // Every leaf resource id under a group's subtree (recursive), for roll-ups.
+  const leafSeen = new Set<string>()
+  const leafIds = (gid: string): string[] => {
+    if (leafSeen.has(gid)) return [] // cycle guard
+    leafSeen.add(gid)
+    const ids: string[] = []
+    for (const r of resByGroup.get(gid) ?? []) ids.push(r.id)
+    for (const cg of childGroups.get(gid) ?? []) ids.push(...leafIds(cg.id))
+    leafSeen.delete(gid)
+    return ids
+  }
+
+  const out: ResourceRow<R>[] = []
+  const walked = new Set<string>()
+  const walk = (g: SchedulerResourceGroup, depth: number): void => {
+    if (walked.has(g.id)) return // cycle guard
+    walked.add(g.id)
+    const isCollapsed = collapsed.has(g.id)
+    out.push({ kind: 'group', id: g.id, title: g.title, depth, color: g.color, collapsed: isCollapsed, childResourceIds: leafIds(g.id) })
+    if (isCollapsed) return
+    for (const cg of childGroups.get(g.id) ?? []) walk(cg, depth + 1)
+    for (const r of resByGroup.get(g.id) ?? []) {
+      out.push({ kind: 'resource', id: r.id, title: r.title ?? r.id, depth: depth + 1, color: r.color, resource: r })
+    }
+  }
+
+  for (const g of childGroups.get('') ?? []) walk(g, 0)
+  // Ungrouped resources trail at the end (no header).
+  for (const r of resByGroup.get('') ?? []) {
+    out.push({ kind: 'resource', id: r.id, title: r.title ?? r.id, depth: 0, color: r.color, resource: r })
+  }
+  return out
+}
+
+/** The leaf resource ids actually visible (resource rows only) in tree order. */
+export function visibleResourceIds<R extends MinResource>(rows: ReadonlyArray<ResourceRow<R>>): string[] {
+  return rows.filter((r) => r.kind === 'resource').map((r) => r.id)
+}

package/src/scheduler-slots.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { availableSlots, mergeIntervals, subtractIntervals, type Interval } from './scheduler-slots'
+
+const D = (h: number, m = 0) => new Date(2026, 0, 5, h, m, 0, 0)
+const iv = (sh: number, sm: number, eh: number, em: number): Interval => ({ start: D(sh, sm), end: D(eh, em) })
+const hhmm = (d: Date) => `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
+const show = (slots: { start: Date; end: Date }[]) => slots.map((s) => `${hhmm(s.start)}-${hhmm(s.end)}`)
+
+describe('mergeIntervals', () => {
+  it('merges overlapping and touching intervals', () => {
+    expect(show(mergeIntervals([iv(9, 0, 10, 0), iv(9, 30, 11, 0), iv(11, 0, 12, 0)]))).toEqual(['09:00-12:00'])
+  })
+})
+
+describe('subtractIntervals', () => {
+  it('cuts occupied blocks out of a base window', () => {
+    const free = subtractIntervals(iv(9, 0, 17, 0), [iv(12, 0, 13, 0)])
+    expect(show(free)).toEqual(['09:00-12:00', '13:00-17:00'])
+  })
+})
+
+describe('availableSlots', () => {
+  it('fills an empty working window with back-to-back slots', () => {
+    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [], durationMin: 60 })
+    expect(show(slots)).toEqual(['09:00-10:00', '10:00-11:00', '11:00-12:00'])
+  })
+
+  it('removes slots that hit a busy booking', () => {
+    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [iv(10, 0, 11, 0)], durationMin: 60 })
+    expect(show(slots)).toEqual(['09:00-10:00', '11:00-12:00'])
+  })
+
+  it('buffers widen what a booking blocks', () => {
+    // busy 10:00-11:00 with a 15-min buffer blocks 09:45-11:15, so the 09:00 slot
+    // (ends 10:00 > 09:45) is gone and only 11:15+ is free (no 60-min slot fits before 12:00).
+    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [iv(10, 0, 11, 0)], durationMin: 60, bufferBeforeMin: 15, bufferAfterMin: 15 })
+    expect(show(slots)).toEqual([]) // 09:00-09:45 too short for 60m; 11:15-12:00 too short
+  })
+
+  it('honours a smaller step (overlapping start times)', () => {
+    const slots = availableSlots({ working: [iv(9, 0, 10, 30)], busy: [], durationMin: 60, stepMin: 30 })
+    expect(show(slots)).toEqual(['09:00-10:00', '09:30-10:30'])
+  })
+
+  it('drops slots before minStart (lead time)', () => {
+    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [], durationMin: 60, minStart: D(10, 0) })
+    expect(show(slots)).toEqual(['10:00-11:00', '11:00-12:00'])
+  })
+
+  it('returns nothing when the duration cannot fit', () => {
+    expect(availableSlots({ working: [iv(9, 0, 9, 45)], busy: [], durationMin: 60 })).toEqual([])
+  })
+})

package/src/scheduler-slots.ts

@@ -0,0 +1,94 @@
+/**
+ * scheduler-slots - the pure core behind Scheduler Pro's *bookable slots /
+ * find-a-time* (Calendly-style). No Svelte, no DOM. Given a resource's working
+ * windows and its busy intervals, it produces the open, bookable slots of a fixed
+ * duration - subtracting busy time (widened by buffers) and anything before a
+ * minimum start (now + lead). Deterministic: the caller supplies all dates.
+ */
+
+export type Interval = { start: Date; end: Date }
+export type Slot = { start: Date; end: Date }
+
+const MS_MIN = 60_000
+
+/** Merge overlapping / touching intervals into a sorted, disjoint list. */
+export function mergeIntervals(intervals: ReadonlyArray<Interval>): Interval[] {
+  const sorted = [...intervals]
+    .filter((i) => i.end.getTime() > i.start.getTime())
+    .sort((a, b) => a.start.getTime() - b.start.getTime())
+  const out: Interval[] = []
+  for (const iv of sorted) {
+    const last = out[out.length - 1]
+    if (last && iv.start.getTime() <= last.end.getTime()) {
+      if (iv.end.getTime() > last.end.getTime()) last.end = iv.end
+    } else out.push({ start: iv.start, end: iv.end })
+  }
+  return out
+}
+
+/** The parts of `[base]` not covered by any of the (merged) `occupied` intervals. */
+export function subtractIntervals(base: Interval, occupied: ReadonlyArray<Interval>): Interval[] {
+  const occ = mergeIntervals(occupied)
+  const out: Interval[] = []
+  let cursor = base.start.getTime()
+  const end = base.end.getTime()
+  for (const o of occ) {
+    const os = o.start.getTime()
+    const oe = o.end.getTime()
+    if (oe <= cursor || os >= end) continue // outside base
+    if (os > cursor) out.push({ start: new Date(cursor), end: new Date(Math.min(os, end)) })
+    cursor = Math.max(cursor, oe)
+    if (cursor >= end) break
+  }
+  if (cursor < end) out.push({ start: new Date(cursor), end: new Date(end) })
+  return out
+}
+
+export type SlotOptions = {
+  working: ReadonlyArray<Interval>
+  busy: ReadonlyArray<Interval>
+  durationMin: number
+  /** Slot start granularity (minutes). Default = `durationMin` (back-to-back slots). */
+  stepMin?: number
+  /** Clear minutes required before / after a busy booking (widens what it blocks). */
+  bufferBeforeMin?: number
+  bufferAfterMin?: number
+  /** Earliest allowed slot start (e.g. now + lead time). Slots before it are dropped. */
+  minStart?: Date
+}
+
+/**
+ * The bookable slots. For each working window, subtract busy time (each busy
+ * interval widened by the buffers) and anything before `minStart`, then step
+ * through the remaining free space emitting `durationMin` slots every `stepMin`.
+ */
+export function availableSlots(opts: SlotOptions): Slot[] {
+  const durMs = Math.max(1, opts.durationMin) * MS_MIN
+  const stepMs = Math.max(1, opts.stepMin ?? opts.durationMin) * MS_MIN
+  const bufB = (opts.bufferBeforeMin ?? 0) * MS_MIN
+  const bufA = (opts.bufferAfterMin ?? 0) * MS_MIN
+  const floor = opts.minStart ? opts.minStart.getTime() : -Infinity
+
+  const occupied: Interval[] = opts.busy.map((b) => ({
+    start: new Date(b.start.getTime() - bufB),
+    end: new Date(b.end.getTime() + bufA),
+  }))
+
+  const out: Slot[] = []
+  for (const w of mergeIntervals(opts.working)) {
+    // Clip the window to `minStart` before subtracting busy.
+    const wStart = Math.max(w.start.getTime(), floor)
+    if (wStart >= w.end.getTime()) continue
+    const free = subtractIntervals({ start: new Date(wStart), end: w.end }, occupied)
+    for (const gap of free) {
+      let s = gap.start.getTime()
+      const gEnd = gap.end.getTime()
+      let guard = 0
+      while (s + durMs <= gEnd && guard++ < 5000) {
+        out.push({ start: new Date(s), end: new Date(s + durMs) })
+        s += stepMs
+      }
+    }
+  }
+  return out
+}

package/src/scheduler-summary.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest'
+import { busyMinutesReducer, columnSummaries, sumReducer } from './scheduler-summary'
+
+type Row = { id: string; amount: number }
+type Ev = { row: Row; start: Date; end: Date }
+const D = (h: number) => new Date(2026, 0, 5, h, 0, 0, 0)
+const ev = (id: string, s: number, e: number, amount: number): Ev => ({ row: { id, amount }, start: D(s), end: D(e) })
+
+const opts = { startOf: (e: Ev) => e.start, endOf: (e: Ev) => e.end, rowOf: (e: Ev) => e.row }
+const cols = [
+  { start: D(9), end: D(10) },
+  { start: D(10), end: D(11) },
+  { start: D(11), end: D(12) },
+]
+
+describe('columnSummaries', () => {
+  it('counts events overlapping each column', () => {
+    const events = [ev('a', 9, 11, 5), ev('b', 10, 12, 3)] // a in cols 0,1; b in cols 1,2
+    expect(columnSummaries(events, cols, 'count', opts)).toEqual([1, 2, 1])
+  })
+
+  it('sums a numeric field per column', () => {
+    const events = [ev('a', 9, 11, 5), ev('b', 10, 12, 3)]
+    expect(columnSummaries(events, cols, sumReducer<Row>('amount'), opts)).toEqual([5, 8, 3])
+  })
+
+  it('yields 0 for empty columns', () => {
+    expect(columnSummaries([], cols, 'count', opts)).toEqual([0, 0, 0])
+    expect(columnSummaries([], cols, sumReducer<Row>('amount'), opts)).toEqual([0, 0, 0])
+  })
+
+  it('clips events to the column for a busy-minutes reducer', () => {
+    const events = [ev('a', 9, 12, 0)] // spans all three hours
+    // Each column is 1h; the event contributes 60 clipped minutes to each.
+    expect(columnSummaries(events, cols, busyMinutesReducer<Row>(), opts)).toEqual([60, 60, 60])
+  })
+
+  it('passes column-clipped items to a custom reducer', () => {
+    const events = [ev('a', 9, 12, 0)]
+    const seen: number[] = []
+    columnSummaries(events, cols, (items) => {
+      seen.push(items.length ? (items[0]!.end.getTime() - items[0]!.start.getTime()) / 60000 : 0)
+      return items.length
+    }, opts)
+    expect(seen).toEqual([60, 60, 60]) // clipped to each 1h column
+  })
+})

package/src/scheduler-summary.ts

@@ -0,0 +1,81 @@
+/**
+ * scheduler-summary - the pure core behind Scheduler Pro's *per-time-column
+ * summary* strip (counts / sums / a custom roll-up aligned to the timeline axis).
+ * No Svelte, no DOM. Each event is clipped to the column it falls in before the
+ * reducer runs, so duration-based reducers (busy minutes) are per-column.
+ */
+
+const MS_MIN = 60_000
+
+/** One event clipped to a column: its row plus the clipped [start, end). */
+export type SummaryItem<TData> = { row: TData; start: Date; end: Date }
+
+/**
+ * How a column's overlapping events roll up to one cell value:
+ *   - `'count'`  - number of events touching the column
+ *   - `{ sum }`  - sum of a numeric row field over those events
+ *   - function   - custom, receives the column-clipped items
+ */
+export type ColumnReducer<TData> =
+  | 'count'
+  | { sum: keyof TData & string }
+  | ((items: SummaryItem<TData>[]) => string | number)
+
+export type SummaryOptions<E, TData> = {
+  startOf: (e: E) => Date
+  endOf: (e: E) => Date
+  rowOf: (e: E) => TData
+}
+
+function overlaps(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
+  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime()
+}
+
+/**
+ * One summary value per column. For each column, collect the events overlapping
+ * it, clip each to the column bounds, then apply `reducer`. Empty columns yield
+ * `0` for `count` / `sum` and `reducer([])` for the function form.
+ */
+export function columnSummaries<E, TData>(
+  events: ReadonlyArray<E>,
+  columns: ReadonlyArray<{ start: Date; end: Date }>,
+  reducer: ColumnReducer<TData>,
+  opts: SummaryOptions<E, TData>,
+): Array<string | number> {
+  return columns.map((col) => {
+    const items: SummaryItem<TData>[] = []
+    for (const e of events) {
+      const s = opts.startOf(e)
+      const en = opts.endOf(e)
+      if (!overlaps(s, en, col.start, col.end)) continue
+      items.push({
+        row: opts.rowOf(e),
+        start: new Date(Math.max(s.getTime(), col.start.getTime())),
+        end: new Date(Math.min(en.getTime(), col.end.getTime())),
+      })
+    }
+    if (reducer === 'count') return items.length
+    if (typeof reducer === 'function') return reducer(items)
+    // { sum: field }
+    const field = reducer.sum
+    let total = 0
+    for (const it of items) {
+      const v = (it.row as Record<string, unknown>)[field as string]
+      if (typeof v === 'number' && Number.isFinite(v)) total += v
+    }
+    return total
+  })
+}
+
+/** Built-in reducer: sum a numeric row field. */
+export function sumReducer<TData>(field: keyof TData & string): ColumnReducer<TData> {
+  return { sum: field }
+}
+
+/** Built-in reducer: count events. */
+export const countReducer = 'count' as const
+
+/** Built-in reducer: total column-clipped busy minutes across the column's events. */
+export function busyMinutesReducer<TData>(): (items: SummaryItem<TData>[]) => number {
+  return (items) => items.reduce((sum, it) => sum + (it.end.getTime() - it.start.getTime()) / MS_MIN, 0)
+}

package/src/schema-designer.ts

@@ -60,7 +60,7 @@ export function updateField(
     if (f.field !== fieldName) {
       return makesPrimary && f.primaryKey ? { ...f, primaryKey: false } : f
     }
-    let next: EntityField = { ...f, ...patch }
+    const next: EntityField = { ...f, ...patch }
     if (patch.type && patch.type !== f.type) {
       if (patch.type !== 'enum') delete next.options
       if (patch.type !== 'relation') delete next.relation

package/src/sources/index.ts

@@ -20,7 +20,7 @@ export {
   type RestAdapter,
   type OffsetLimitOptions,
 } from './rest-adapters'
-export { introspectSupabaseTable, type IntrospectSupabaseOptions } from './introspect-supabase'
+export { introspectSupabaseTable, listSupabaseTables, type IntrospectSupabaseOptions } from './introspect-supabase'
 export {
   createSupabaseRealtime,
   type SupabaseRealtimeConfig,

package/src/sources/introspect-supabase.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { introspectSupabaseTable } from './introspect-supabase'
+import { introspectSupabaseTable, listSupabaseTables } from './introspect-supabase'
 
 type Parts = { openapi?: unknown; openapiStatus?: number; csv?: string; sample?: unknown }
 
@@ -98,3 +98,15 @@ describe('introspectSupabaseTable', () => {
     expect(schema).toBeNull()
   })
 })
+
+describe('listSupabaseTables', () => {
+  it('lists table names from the OpenAPI definitions (sorted)', async () => {
+    const openapi = { definitions: { orders: {}, customers: {}, deals: {} } }
+    const tables = await listSupabaseTables('https://x.supabase.co', 'anon', fetchFor({ openapi }))
+    expect(tables).toEqual(['customers', 'deals', 'orders'])
+  })
+
+  it('returns [] when the OpenAPI doc is blocked or the key is wrong', async () => {
+    expect(await listSupabaseTables('https://x.supabase.co', 'anon', fetchFor({ openapiStatus: 401 }))).toEqual([])
+  })
+})

package/src/sources/introspect-supabase.ts

@@ -106,6 +106,26 @@ async function viaSample(o: Required<IntrospectSupabaseOptions>, base: string):
   }))
 }
 
+/** List a Supabase project's tables from its PostgREST OpenAPI doc (URL + anon key).
+ *  Returns the exposed table names (sorted), or `[]` when the doc can't be read
+ *  (CORS-blocked, bad key). Lets the Studio wizard offer a table picker instead of
+ *  making the user hand-type the table name. */
+export async function listSupabaseTables(url: string, key: string, fetchFn: typeof fetch = globalThis.fetch): Promise<string[]> {
+  const base = url.replace(/\/+$/, '')
+  let res: Response
+  try {
+    res = await fetchFn(`${base}/rest/v1/`, { headers: { apikey: key, Authorization: `Bearer ${key}`, Accept: 'application/json' } })
+  } catch {
+    return []
+  }
+  if (!res.ok) return []
+  let spec: any
+  try { spec = await res.json() } catch { return [] }
+  const defs: Record<string, unknown> = spec?.definitions ?? spec?.components?.schemas ?? {}
+  // PostgREST also lists RPCs under `paths` as `/rpc/...`; `definitions` are the tables/views.
+  return Object.keys(defs).sort((a, b) => a.localeCompare(b))
+}
+
 /** Introspect a Supabase/PostgREST table into an EntitySchema, or null. */
 export async function introspectSupabaseTable<TData extends RowData = RowData>(
   options: IntrospectSupabaseOptions,

package/src/studio/copilot-core.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+import { buildCopilotMessages, projectFromModelText } from './copilot-core'
+import { createProject, serializeProject } from './project'
+import type { EntitySchema } from '../schema'
+
+const customers: EntitySchema = {
+  name: 'customers',
+  label: 'Customers',
+  idField: 'id',
+  fields: [
+    { field: 'id', label: 'Id', type: 'text', primaryKey: true },
+    { field: 'name', label: 'Name', type: 'text' },
+  ],
+}
+
+describe('copilot core', () => {
+  it('builds a request carrying the model rules, the current project, and the instruction', () => {
+    const p = createProject([customers])
+    const { system, messages } = buildCopilotMessages('Add a status enum field to customers', p)
+    expect(system).toMatch(/COMPLETE updated project as JSON/)
+    expect(system).toMatch(/PRESERVE everything/)
+    expect(system).toContain('board') // block kinds listed from the palette
+    expect(system).toContain('radio-group') // component keys listed from the registry
+    expect(messages).toHaveLength(1)
+    expect(messages[0]!.content).toContain('"customers"') // current project inlined
+    expect(messages[0]!.content).toContain('Add a status enum field to customers')
+  })
+
+  it('parses a clean JSON reply into a validated project', () => {
+    const p = createProject([customers])
+    const out = projectFromModelText(serializeProject(p))
+    expect(out.entities[0]!.name).toBe('customers')
+  })
+
+  it('tolerates fenced and prose-wrapped replies', () => {
+    const json = serializeProject(createProject([customers]))
+    expect(projectFromModelText('```json\n' + json + '\n```').entities).toHaveLength(1)
+    expect(projectFromModelText('Here is the updated project:\n' + json + '\nDone!').entities).toHaveLength(1)
+  })
+
+  it('rejects non-JSON and invalid projects with useful errors', () => {
+    expect(() => projectFromModelText('Sorry, I cannot do that.')).toThrow(/no JSON object/)
+    expect(() => projectFromModelText('{"entities": [], "screens": []}')).toThrow(/invalid project|entity/i)
+  })
+})

package/src/studio/copilot-core.ts

@@ -0,0 +1,65 @@
+/**
+ * Studio Copilot - the pure, testable core. Builds the model request for "edit
+ * this project per the user's instruction" and parses/validates the model's
+ * reply back into a StudioProject. No network here: the CLI designer server
+ * does the actual Anthropic call (keys stay server-side), and the designer
+ * additionally re-validates + puts the result on the undo stack, so a bad
+ * edit is one Ctrl+Z away.
+ */
+import { parseProject, serializeProject, validateProject, blockPalette, type StudioProject } from './project.js'
+import { UI_COMPONENT_REGISTRY } from './ui-components.js'
+
+export type CopilotMessages = {
+  system: string
+  messages: Array<{ role: 'user'; content: string }>
+}
+
+/** The system + user messages for one copilot edit round. */
+export function buildCopilotMessages(prompt: string, project: StudioProject): CopilotMessages {
+  const kinds = blockPalette.map((p) => p.kind).join(', ')
+  const components = UI_COMPONENT_REGISTRY.map((c) => c.key).join(', ')
+  const system = `You are SvGrid Studio's copilot. You edit a Studio project - the JSON model of a data app - according to the user's instruction, and return the COMPLETE updated project as JSON.
+
+The model, briefly:
+- entities: EntitySchema[] - { name, label, idField, fields: [{ field, label, type, primaryKey?, required?, formula?, options?: [{value,label,color?}], relation?: { entity, labelField } }] }. Field types: text | number | boolean | date | datetime | enum | relation | json.
+- screens: [{ id, title, route, entity?, blocks: [{ id, config: { kind, ... } }], nav?: { show, label?, order? } }]. Block kinds: ${kinds}. A 'component' block is { kind: 'component', component: <key>, props: {...} } with component keys: ${components}.
+- dataSources: { [entityName]: { kind: 'memory'|'sql'|'rest'|'supabase'|'pglite', ... } }. theme, auth, access (RBAC), i18n, deploy as configured.
+- validations on an entity: [{ field, op, value|compareTo, message }].
+
+Rules:
+- Return ONLY the full updated project JSON (no prose, no markdown fence).
+- PRESERVE everything the instruction does not ask to change - ids, screens, entities, config. Never renumber or drop existing ids.
+- New ids: short kebab/lower-camel strings unique within the project.
+- New entities need at least an id/primary-key field and a label-ish field; give enum fields options with value+label; seed realistic demo data is NOT required.
+- New screens need a unique route and at least one block bound to their entity.
+- Prefer editing over rebuilding; keep the user's structure and naming style.`
+  return {
+    system,
+    messages: [
+      {
+        role: 'user',
+        content: `Current project JSON:\n${serializeProject(project)}\n\nInstruction: ${prompt}\n\nReturn the complete updated project JSON.`,
+      },
+    ],
+  }
+}
+
+/** Parse the model's reply into a validated StudioProject. Tolerates a fenced
+ *  code block or stray prose around the JSON; throws with a useful message when
+ *  the reply isn't a valid project. */
+export function projectFromModelText(text: string): StudioProject {
+  let candidate = text.trim()
+  const fence = candidate.match(/```(?:json)?\s*([\s\S]*?)```/)
+  if (fence) candidate = fence[1]!.trim()
+  if (!candidate.startsWith('{')) {
+    // Stray prose: cut to the outermost object literal.
+    const start = candidate.indexOf('{')
+    const end = candidate.lastIndexOf('}')
+    if (start === -1 || end <= start) throw new Error('Copilot reply contained no JSON object.')
+    candidate = candidate.slice(start, end + 1)
+  }
+  const project = parseProject(candidate) // throws on malformed/invalid shapes
+  const errors = validateProject(project).filter((i) => i.level === 'error')
+  if (errors.length) throw new Error(`Copilot returned an invalid project: ${errors.map((e) => e.message).join(' ')}`)
+  return project
+}

package/src/studio/deploy-cli.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import { deployCommands, missingEnvKeys, resolveDeployTarget } from './deploy-cli'
+
+describe('resolveDeployTarget', () => {
+  it('an explicit --target wins and is validated', () => {
+    expect(resolveDeployTarget({ flag: 'netlify', configJson: '{"deploy":"vercel"}' })).toEqual({ ok: true, provider: 'netlify', source: 'flag' })
+    const bad = resolveDeployTarget({ flag: 'heroku' })
+    expect(bad.ok).toBe(false)
+    if (!bad.ok) expect(bad.reason).toMatch(/Unknown --target "heroku"/)
+  })
+
+  it('falls back to studio.config.json deploy, ignoring auto/unset (never guesses)', () => {
+    expect(resolveDeployTarget({ configJson: '{"deploy":"cloudflare"}' })).toEqual({ ok: true, provider: 'cloudflare', source: 'config' })
+    expect(resolveDeployTarget({ configJson: '{"deploy":"auto"}' }).ok).toBe(false)
+    expect(resolveDeployTarget({ configJson: '{}' }).ok).toBe(false)
+    expect(resolveDeployTarget({ configJson: 'not json' }).ok).toBe(false)
+  })
+
+  it('detects the provider from a pinned SvelteKit adapter', () => {
+    const cfg = "import adapter from '@sveltejs/adapter-vercel'\nexport default { kit: { adapter: adapter() } }"
+    expect(resolveDeployTarget({ svelteConfig: cfg })).toEqual({ ok: true, provider: 'vercel', source: 'adapter' })
+    // adapter-auto is not a concrete provider - refuse with guidance.
+    const auto = resolveDeployTarget({ svelteConfig: "import adapter from '@sveltejs/adapter-auto'" })
+    expect(auto.ok).toBe(false)
+    if (!auto.ok) expect(auto.reason).toMatch(/No deploy target configured/)
+  })
+
+  it('config beats adapter; flag beats both', () => {
+    const svelteConfig = "import adapter from '@sveltejs/adapter-node'"
+    expect(resolveDeployTarget({ configJson: '{"deploy":"netlify"}', svelteConfig })).toMatchObject({ provider: 'netlify', source: 'config' })
+    expect(resolveDeployTarget({ flag: 'cloudflare', configJson: '{"deploy":"netlify"}', svelteConfig })).toMatchObject({ provider: 'cloudflare', source: 'flag' })
+  })
+})
+
+describe('deployCommands', () => {
+  it('providers build first, then run the same one-liners the generated deploy script uses', () => {
+    expect(deployCommands('vercel')).toMatchObject({ build: 'npm run build', deploy: 'npx vercel deploy --prod' })
+    expect(deployCommands('netlify').deploy).toBe('npx netlify deploy --build --prod')
+    expect(deployCommands('cloudflare').deploy).toBe('npx wrangler pages deploy')
+  })
+
+  it('node has no provider command - instructions only', () => {
+    const plan = deployCommands('node')
+    expect(plan.deploy).toBeNull()
+    expect(plan.notes.join('\n')).toMatch(/docker build/)
+  })
+})
+
+describe('missingEnvKeys', () => {
+  it('flags declared-but-unset keys, ignoring comments and filled values', () => {
+    const example = '# note\nDATABASE_URL=\nSESSION_SECRET=change-me\n# VITE_SVPRO_KEY=\n'
+    expect(missingEnvKeys(example, 'DATABASE_URL=postgres://x\n')).toEqual(['SESSION_SECRET'])
+    expect(missingEnvKeys(example, null)).toEqual(['DATABASE_URL', 'SESSION_SECRET'])
+    expect(missingEnvKeys(null, null)).toEqual([])
+  })
+})