@elytracms/studio 0.0.101 → 0.0.103

package/convex/record-functions.ts

@@ -3,7 +3,6 @@ import type { GenericId } from 'convex/values'
 import type { RegisteredMutation, RegisteredQuery } from 'convex/server'
 import {
   PersistenceValidationError,
-  matchesRecordQuery,
   orderRecords,
   recordSlots,
   recordWireRow,
@@ -65,33 +64,6 @@ type RecordDoc = {
   updatedAt: string
 }
 
-/**
- * TOLERANT READ (marked; EC-616's redirect move, the EC-587 precedent): a kind whose rows
- * used to live in a table of their own declares where, so a deployment whose functions
- * moved but whose migration has not run yet serves exactly what it served before — no
- * gap. Reads union the legacy rows a record does not shadow; a save of a legacy-only id
- * lifts it (the record is created from the legacy columns, the legacy row deleted, one
- * transaction); a remove deletes both. Writes NEVER go to the legacy table. Removed with
- * the legacy table once its migration is reported run on every deployment (a gated item).
- */
-export interface LegacyRecordSource {
-  /** The legacy row for one id: its columns and stamps, and a handle to delete it. */
-  find(ctx: QueryCtx | MutationCtx, recordId: string): Promise<LegacyRecord | null>
-  /** Every legacy row (the tables are small editorial sets: read whole). */
-  list(ctx: QueryCtx | MutationCtx): Promise<LegacyRecord[]>
-  /** Delete one legacy row (after its record exists). */
-  remove(ctx: MutationCtx, record: LegacyRecord): Promise<void>
-}
-
-export interface LegacyRecord {
-  recordId: string
-  columns: RecordColumns
-  createdAt: string
-  updatedAt: string
-  /** The legacy row's own id, opaque to the factory. */
-  handle: unknown
-}
-
 /** A `PersistenceValidationError` from the shared rule, as the `ConvexError` the client maps back. */
 function asConvexValidation(error: unknown): unknown {
   if (!(error instanceof PersistenceValidationError)) return error
@@ -161,47 +133,26 @@ function indexedDoc(doc: RecordDoc): IndexedRecord & { doc: RecordDoc } {
 }
 
 /**
- * The wire rows of one kind for a query — the records, plus (while a legacy source is
- * declared) the legacy rows no record shadows, matched and ordered by the SAME pure
- * functions the in-memory store uses. The one list reader: the kind's `list` and any
- * server-side reader of the kind (the delivery snapshot) go through it.
+ * The wire rows of one kind for a query, matched and ordered by the store's query. The one
+ * list reader: the kind's `list` and any server-side reader of the kind (the delivery
+ * snapshot) go through it.
  */
 export async function listRecordWire(
   ctx: QueryCtx | MutationCtx,
   kind: AnyRecordKind,
   resolved: ResolvedRecordQuery,
-  legacy?: LegacyRecordSource,
 ): Promise<RecordWireRow[]> {
-  if (!legacy) return (await queryRecordDocs(ctx, kind, resolved)).map((doc) => recordDocWire(kind, doc))
-  // TOLERANT READ (marked): the union is read unbounded and ordered once, here.
-  const { limit: _limit, ...unbounded } = resolved
-  const docs = await queryRecordDocs(ctx, kind, { ...unbounded, order: 'asc' })
-  const shadowed = new Set(docs.map((doc) => doc.recordId))
-  const legacyRows = (await legacy.list(ctx))
-    .filter((row) => !shadowed.has(row.recordId))
-    .map((row) => ({
-      id: row.recordId,
-      slots: recordSlots(kind, row.columns, row.createdAt),
-      columns: row.columns,
-      wire: recordWireRow(kind, row.recordId, row.columns, row.createdAt, row.updatedAt),
-    }))
-    .filter((row) => matchesRecordQuery(row, resolved))
-  // Legacy rows predate every record, so they lead in insertion order.
-  const union = [...legacyRows, ...docs.map((doc) => ({ ...indexedDoc(doc), wire: recordDocWire(kind, doc) }))]
-  return orderRecords(kind, union, resolved).map((row) => row.wire)
+  return (await queryRecordDocs(ctx, kind, resolved)).map((doc) => recordDocWire(kind, doc))
 }
 
-/** One record's wire row by id — the record, else (while declared) its legacy row. */
+/** One record's wire row by id. */
 export async function getRecordWire(
   ctx: QueryCtx | MutationCtx,
   kind: AnyRecordKind,
   recordId: string,
-  legacy?: LegacyRecordSource,
 ): Promise<RecordWireRow | null> {
   const doc = await findRecordDoc(ctx, kind, recordId)
-  if (doc) return recordDocWire(kind, doc)
-  const old = legacy ? await legacy.find(ctx, recordId) : null // TOLERANT READ (marked)
-  return old ? recordWireRow(kind, old.recordId, old.columns, old.createdAt, old.updatedAt) : null
+  return doc ? recordDocWire(kind, doc) : null
 }
 
 /**
@@ -214,14 +165,10 @@ export async function saveRecord(
   recordId: string,
   write: Readonly<Record<string, unknown>>,
   stamps: { createdAt: string; updatedAt: string },
-  legacy?: LegacyRecordSource,
 ): Promise<RecordWireRow> {
   const existing = await findRecordDoc(ctx, kind, recordId)
-  // TOLERANT READ (marked): a legacy-only record is edited from its legacy columns.
-  const lifted = !existing && legacy ? await legacy.find(ctx, recordId) : null
-  const stored = existing?.data ?? lifted?.columns
-  const columns = rethrowAsConvex(() => resolveRecordSave(kind, recordId, stored, write))
-  const createdAt = existing?.createdAt ?? lifted?.createdAt ?? stamps.createdAt
+  const columns = rethrowAsConvex(() => resolveRecordSave(kind, recordId, existing?.data, write))
+  const createdAt = existing?.createdAt ?? stamps.createdAt
   const slots = recordSlots(kind, columns, createdAt)
   if (existing) {
     // `key1`/`key2` are always written: an edit that empties a key unsets its slot.
@@ -243,7 +190,6 @@ export async function saveRecord(
       createdAt,
       updatedAt: stamps.updatedAt,
     })
-    if (lifted && legacy) await legacy.remove(ctx, lifted)
   }
   return recordWireRow(kind, recordId, columns, createdAt, stamps.updatedAt)
 }
@@ -256,14 +202,8 @@ export interface RecordFunctions {
   remove: RegisteredMutation<'public', Record<string, unknown>, Promise<void>>
 }
 
-export interface RecordFunctionsOptions {
-  /** TOLERANT READ (marked) — see {@link LegacyRecordSource}. Only a kind that moved declares one. */
-  legacy?: LegacyRecordSource
-}
-
 /** The public CRUD functions of one record kind — see the module header. */
-export function defineRecordFunctions(kind: AnyRecordKind, options: RecordFunctionsOptions = {}): RecordFunctions {
-  const { legacy } = options
+export function defineRecordFunctions(kind: AnyRecordKind): RecordFunctions {
   const idArg = { [kind.idKey]: v.string() }
   const columnArgs = Object.fromEntries(
     [...Object.keys(kind.fields), 'meta', 'metaPatch'].map((column) => [column, v.optional(v.any())]),
@@ -274,14 +214,10 @@ export function defineRecordFunctions(kind: AnyRecordKind, options: RecordFuncti
     handler: async (ctx, args: Record<string, unknown>) => {
       await requireCapability(ctx, kind.access.write)
       const { [kind.idKey]: recordId, createdAt, updatedAt, ...write } = args
-      return saveRecord(
-        ctx,
-        kind,
-        recordId as string,
-        write,
-        { createdAt: createdAt as string, updatedAt: updatedAt as string },
-        legacy,
-      )
+      return saveRecord(ctx, kind, recordId as string, write, {
+        createdAt: createdAt as string,
+        updatedAt: updatedAt as string,
+      })
     },
   })
 
@@ -289,7 +225,7 @@ export function defineRecordFunctions(kind: AnyRecordKind, options: RecordFuncti
     args: idArg,
     handler: async (ctx, args: Record<string, unknown>) => {
       await requireCapability(ctx, kind.access.read)
-      return getRecordWire(ctx, kind, args[kind.idKey] as string, legacy)
+      return getRecordWire(ctx, kind, args[kind.idKey] as string)
     },
   })
 
@@ -304,7 +240,7 @@ export function defineRecordFunctions(kind: AnyRecordKind, options: RecordFuncti
     handler: async (ctx, args: RecordQuery) => {
       await requireCapability(ctx, kind.access.read)
       const resolved = rethrowAsConvex(() => resolveRecordQuery(kind, args))
-      return listRecordWire(ctx, kind, resolved, legacy)
+      return listRecordWire(ctx, kind, resolved)
     },
   })
 
@@ -315,9 +251,6 @@ export function defineRecordFunctions(kind: AnyRecordKind, options: RecordFuncti
       const recordId = args[kind.idKey] as string
       const doc = await findRecordDoc(ctx, kind, recordId)
       if (doc) await ctx.db.delete(doc._id)
-      // TOLERANT READ (marked): a legacy row of the same id goes too, or it would resurface.
-      const old = legacy ? await legacy.find(ctx, recordId) : null
-      if (old && legacy) await legacy.remove(ctx, old)
     },
   })
 

package/convex/redirects.ts

@@ -1,18 +1,7 @@
-import { internalMutationGeneric } from 'convex/server'
-import type { MutationBuilder } from 'convex/server'
-import {
-  PersistenceValidationError,
-  recordColumnsOf,
-  recordSlots,
-  redirectRecordKind,
-  resolveRecordQuery,
-  resolveRecordSave,
-} from '@elytracms/core/persistence'
+import { recordEntryFromWire, redirectRecordKind, resolveRecordQuery } from '@elytracms/core/persistence'
 import type { RedirectEntry } from '@elytracms/core/persistence'
-import type { DataModel, MutationCtx, QueryCtx } from './functions'
-import { defineRecordFunctions, findRecordDoc, listRecordWire } from './record-functions'
-import type { LegacyRecord, LegacyRecordSource } from './record-functions'
-import { recordEntryFromWire } from '@elytracms/core/persistence'
+import type { QueryCtx } from './functions'
+import { defineRecordFunctions, listRecordWire } from './record-functions'
 
 /**
  * Editorial redirects persistence (EC-303) — since EC-616 the redirect RECORD KIND over
@@ -22,112 +11,18 @@ import { recordEntryFromWire } from '@elytracms/core/persistence'
  * `export * from '@elytracms/studio/convex/redirects'` line are unchanged. Content-gated
  * (a viewer reads, an editor writes), NOT admin-only — redirects are content.
  *
- * ## The move from the `redirects` table (stored data — both production consumers hold real redirects)
- *
- * The EC-587 precedent, with no gap:
- *
- * - **writes go to `records`** (kind `redirect`); nothing writes the legacy table again;
- * - **reads union the legacy rows no record shadows** — the TOLERANT READ below, marked:
- *   a deployment with these functions pushed and the migration NOT yet run serves the
- *   same redirects it served before (`list`, `get`, the delivery snapshot);
- * - a save of a legacy-only redirect lifts it (record from its columns, legacy row
- *   deleted, one transaction); a remove deletes both;
- * - **`redirects:migrateLegacy`** moves every legacy row in one idempotent internal
- *   mutation and reports counts — run per deployment (both consumers + the prod harness:
- *   owner-run); the legacy table and this tolerant read are dropped together once it is
- *   reported run everywhere (a gated item, like EC-587's alt column).
+ * The legacy `redirects` table, its tolerant read and its one-time move
+ * (`redirects:migrateLegacy`) are deleted (EC-708), after every deployment's scan read 0
+ * legacy rows: `records` is the one home.
  */
-
-type LegacyRedirectDoc = DataModel['redirects']['document']
-
-/** TOLERANT READ (marked) — the legacy `redirects` table as the kind's legacy source. */
-const legacyRedirects: LegacyRecordSource = {
-  find: async (ctx, recordId) => {
-    const row = await ctx.db
-      .query('redirects')
-      .withIndex('by_redirect', (q) => q.eq('redirectId', recordId))
-      .first()
-    return row ? legacyRecord(row) : null
-  },
-  list: async (ctx) => (await ctx.db.query('redirects').withIndex('by_redirect').collect()).map(legacyRecord),
-  remove: async (ctx, record) => {
-    await ctx.db.delete(record.handle as LegacyRedirectDoc['_id'])
-  },
-}
-
-function legacyRecord(row: LegacyRedirectDoc): LegacyRecord {
-  return {
-    recordId: row.redirectId,
-    columns: recordColumnsOf(redirectRecordKind, row),
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    handle: row._id,
-  }
-}
-
-export const { save, get, list, remove } = defineRecordFunctions(redirectRecordKind, { legacy: legacyRedirects })
+export const { save, get, list, remove } = defineRecordFunctions(redirectRecordKind)
 
 /**
- * Every stored redirect of this deployment (records + the tolerant legacy read), ordered
- * by `from` — the ONE server-side reader; the delivery snapshot projects it through
- * `readLiveRedirects` (EC-590 / EC-627 / EC-628: the one live-redirect rule).
+ * Every stored redirect of this deployment, ordered by `from` — the ONE server-side
+ * reader; the delivery snapshot projects it through `readLiveRedirects` (EC-590 / EC-627
+ * / EC-628: the one live-redirect rule).
  */
 export async function loadRedirectEntries(ctx: QueryCtx, projectId: string): Promise<RedirectEntry[]> {
-  const rows = await listRecordWire(ctx, redirectRecordKind, resolveRecordQuery(redirectRecordKind), legacyRedirects)
+  const rows = await listRecordWire(ctx, redirectRecordKind, resolveRecordQuery(redirectRecordKind))
   return rows.map((row) => recordEntryFromWire(redirectRecordKind, row, projectId))
 }
-
-/**
- * EC-616 — move every legacy `redirects` row into `records` (kind `redirect`), the
- * redirect move's migration. Per row: a record of the same id already exists (a save
- * lifted it, or an earlier run) → the legacy row is dropped as shadowed; otherwise the
- * row's columns are written as a record CREATE through the one rule (`resolveRecordSave`
- * — a legacy row the current schema refuses is REPORTED and left where it is, still
- * served by the tolerant read, never dropped silently) and the legacy row deleted.
- * Idempotent: a second run scans nothing.
- *
- * Internal: an admin runs it from the CLI, once per deployment —
- * `npx convex run redirects:migrateLegacy` (no args). Built on the RAW internal-mutation
- * builder, deliberately outside the write-chokepoint triggers: the served redirect set is
- * identical before and after by construction (the tolerant read), so the move needs no
- * revalidation — through the triggers it would schedule two sweeps per row (an insert
- * into `records`, a delete from `redirects`). One transaction: Convex bounds it at 8192
- * written rows, far above any editorial redirect set (a production site's import holds 192).
- */
-export const migrateLegacy = (internalMutationGeneric as MutationBuilder<DataModel, 'internal'>)({
-  args: {},
-  handler: async (ctx) => {
-    const legacy = await ctx.db.query('redirects').withIndex('by_redirect').collect()
-    const moved: string[] = []
-    const shadowed: string[] = []
-    const refused: Array<{ redirectId: string; message: string }> = []
-    for (const row of legacy) {
-      const record = legacyRecord(row)
-      if (await findRecordDoc(ctx as unknown as MutationCtx, redirectRecordKind, record.recordId)) {
-        await ctx.db.delete(row._id)
-        shadowed.push(record.recordId)
-        continue
-      }
-      let columns: Record<string, unknown>
-      try {
-        columns = resolveRecordSave(redirectRecordKind, record.recordId, undefined, record.columns)
-      } catch (error) {
-        if (!(error instanceof PersistenceValidationError)) throw error
-        refused.push({ redirectId: record.recordId, message: error.message })
-        continue
-      }
-      const slots = recordSlots(redirectRecordKind, columns, record.createdAt)
-      await ctx.db.insert('records', {
-        kind: redirectRecordKind.kind,
-        recordId: record.recordId,
-        data: columns,
-        at: slots.at,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt,
-      })
-      await ctx.db.delete(row._id)
-      moved.push(record.recordId)
-    }
-    return { scanned: legacy.length, moved: moved.length, shadowed: shadowed.length, refused, movedIds: moved }
-  },
-})

package/convex/schema.ts

@@ -239,10 +239,10 @@ export default defineSchema({
     origin: v.optional(v.string()),
     // EC-585: which mutation recorded the row — 'publish' (`publishDocument`, the only
     // kind `publishDocumentVersion` pins) or 'snapshot' (`saveDocumentVersion`: a restore
-    // point). Optional ONLY for rows recorded before EC-585 (read through
-    // `isPinnableVersion`, which keeps a kind-less `label: 'published'` row pinnable). A
-    // top-level scalar beside the folded snapshot: it adds no nesting depth.
-    kind: v.optional(v.union(v.literal('publish'), v.literal('snapshot'))),
+    // point). Required (EC-708: every deployment stamped and read 0 kind-less rows first;
+    // the push refuses a row without it). A top-level scalar beside the folded snapshot: it
+    // adds no nesting depth.
+    kind: v.union(v.literal('publish'), v.literal('snapshot')),
     createdAt: v.string(),
   })
     .index('by_doc', ['collection', 'docId'])
@@ -259,7 +259,6 @@ export default defineSchema({
     byteSize: v.number(),
     width: v.optional(v.number()),
     height: v.optional(v.number()),
-    alt: v.optional(v.string()),
     /** Editable display title (EC-152; persisted for parity with in-memory — EC-153). */
     title: v.optional(v.string()),
     storageKey: v.string(),
@@ -306,24 +305,6 @@ export default defineSchema({
     .index('by_storage', ['storageKey'])
     .index('by_thumb_storage', ['thumb.storageKey']),
 
-  /**
-   * Editorial redirects (EC-303) — 301/302 forwards an editor owns, stored as
-   * DATA (not config) so they change dynamically without a deploy. The delivery
-   * snapshot projects enabled entries onto the routing `RedirectRecord` the
-   * catch-all resolves; static/infra redirects stay native (next.config/vercel).
-   */
-  redirects: defineTable({
-    redirectId: v.string(),
-    from: v.string(),
-    to: v.string(),
-    permanent: v.boolean(),
-    enabled: v.boolean(),
-    // Schema-driven additive-field bag (EC-311 Tier 2) — see the `assets.meta` bag.
-    meta: v.optional(v.any()),
-    createdAt: v.string(),
-    updatedAt: v.string(),
-  }).index('by_redirect', ['redirectId']),
-
   /**
    * The generic RECORD STORE (EC-616) — one row per record of a DECLARED record kind
    * (`defineRecordKind` in `@elytracms/core/persistence`): the engine's own kinds and

package/convex/triggers.ts

@@ -34,8 +34,9 @@ import { scheduleRevalidate } from './revalidate'
  *
  * - `cmsDocuments` — only when the live pin (`publishedVersion`) moves
  *   (`publish` / `unpublish`), or a pinned row is deleted (`delete`);
- * - `records` of the redirect kind (EC-616; EC-510 before it on the `redirects` table) —
- *   every write (`redirects`; the row IS the live state); no other record kind;
+ * - `records` of the redirect kind (EC-616; EC-510 before it on the legacy `redirects`
+ *   table, deleted by EC-708) — every write (`redirects`; the row IS the live state); no
+ *   other record kind;
  * - `assets` (EC-579) — every edit and delete (`asset`); a create fires nothing.
  *
  * The snapshot reads one more table, `documentVersions`, but only the version a
@@ -127,22 +128,14 @@ triggers.register('cmsDocuments', async (ctx, change) => {
  * no-op, and a redirect save is an explicit editorial action, not a keystroke
  * (EC-501's cost argument does not transfer).
  */
-triggers.register('redirects', async (ctx) => {
-  await scheduleRevalidate(ctx, { kind: 'redirects' })
-})
-
 /**
  * The generic record store (EC-616). Of all record kinds, ONLY the engine's redirect
  * kind is projected onto the live wire (`delivery.ts` reads it through
  * `loadRedirectEntries`), so only a write to a `redirect` row revalidates — with exactly
- * the event the legacy `redirects` table fired above (EC-510: every write, the receiver
- * answers with the sweep). Every other kind — an addon's submissions, analytics rows —
- * is never on the wire and fires nothing; a kind that starts reaching the snapshot
- * belongs in this check.
- *
- * Since the move, a redirect write is a `records` write; the legacy table's trigger
- * above still fires for the transitional deletes (a save lifting a legacy-only redirect
- * deletes its legacy row: two sweeps for that one save, until the migration ran).
+ * the event the legacy `redirects` table fired (EC-510: every write, the receiver answers
+ * with the sweep). Every other kind — an addon's submissions, analytics rows — is never
+ * on the wire and fires nothing; a kind that starts reaching the snapshot belongs in this
+ * check.
  */
 triggers.register('records', async (ctx, change) => {
   const kind = (change.newDoc ?? change.oldDoc)?.kind

package/dist/components/ai/ai-chat-panel.js

@@ -3,13 +3,13 @@ import { useCallback, useMemo, useReducer, useRef, useState } from 'react';
 import { MessageSquarePlus, X } from 'lucide-react';
 import { DefaultChatTransport, lastAssistantMessageIsCompleteWithToolCalls } from 'ai';
 import { useChat } from '@ai-sdk/react';
-import { createCollectionRegistry, resolveDocumentTitle, } from '@elytracms/core/cms-core';
+import { createCollectionRegistry } from '@elytracms/core/cms-core';
 import { Button, Heading, Row, Spacer, Text } from '@elytracms/studio/ui';
 import { translate } from '../../lib/i18n/index.js';
 import { STUDIO_PROJECT_ROUTE, studioPath, useNavigate } from '@elytracms/studio/router';
 import { resolveDeploymentAi } from '../../lib/workspace/index.js';
 import { getStudioOperations } from '../../lib/operations/index.js';
-import { DEFAULT_MAX_STEPS, buildChatContext, chatReviewReducer, clearConversation, createChatCandidateStore, createChatToolExecutor, guardAiRouteFetch, initialChatReviewState, introducedErrors, isAiRouteNotMountedError, renderCurrentDocumentSection, resolveAiConfig, resolveChatTarget, resolveKnowledge, withStepCap, } from '../../lib/ai/index.js';
+import { DEFAULT_MAX_STEPS, buildChatContext, chatReviewReducer, clearConversation, createChatCandidateStore, createChatToolExecutor, guardAiRouteFetch, initialChatReviewState, introducedErrors, isAiRouteNotMountedError, knowledgeFieldOf, modelFacingTitle, renderCurrentDocumentSection, resolveAiConfig, resolveChatTarget, resolveKnowledge, withStepCap, } from '../../lib/ai/index.js';
 import { getAiCurrentDocument } from '../../lib/ai-current-document.js';
 import { useCms } from '../cms/cms-store.js';
 import { AssistantTurn, ChatErrorNote, Conversation, ConversationEmpty, PromptInput, ToolStatus, UserTurn, WorkingIndicator, describeToolPart, messageText, segmentMessageParts, } from './chat-ui.js';
@@ -84,11 +84,14 @@ export function AiChatPanel() {
                 if (!result.ok)
                     return [];
                 const target = cms.getCollection(collection);
+                // EC-741: the title the model reads — and the query is matched against — comes
+                // from the projected values, so an excluded field is neither shown nor probeable.
+                const lookupManifest = cms.validateOptions.lookupManifest;
                 return result.value
                     .map((rec) => ({
                     id: rec.document.id,
                     title: target
-                        ? resolveDocumentTitle(target, localeValues(rec.document), rec.document.id)
+                        ? modelFacingTitle(target, localeValues(rec.document), rec.document.id, lookupManifest ? { lookupManifest } : {})
                         : rec.document.id,
                 }))
                     .filter((r) => matches(query, r.title, r.id));
@@ -142,8 +145,8 @@ export function AiChatPanel() {
         const result = await operations.documents.list({ projectId, collection: source.collectionId });
         if (!result.ok)
             return [];
-        const target = cms.getCollection(source.collectionId);
-        const field = source.field ?? target?.fields.find((f) => f.type === 'text' || f.type === 'richText')?.name;
+        // EC-741: the default prose field is never an `ai.exclude` one.
+        const field = knowledgeFieldOf(source, cms.getCollection(source.collectionId));
         return result.value
             .map((rec) => {
             const values = localeValues(rec.document);