@elytracms/studio 0.0.14 → 0.0.15

package/convex/cms.ts

@@ -1,9 +1,6 @@
-import type { CmsDocument } from '@elytracms/core/cms-core'
 import { v } from 'convex/values'
 import { mutation, query } from './functions'
 import { requireRole } from './guard'
-import { maintainDocumentReferences, removeDocumentReferences } from './referenceMaintenance'
-import { scheduleRevalidate } from './revalidate'
 
 /**
  * CMS document persistence (EC-043). The backend stores **documents only**
@@ -30,22 +27,11 @@ export const upsertDocument = mutation({
       .first()
     if (existing) {
       // EC-153 parity: updates preserve `createdAt`, exactly like in-memory.
+      // EC-286: the write-chokepoint trigger reindexes references in-transaction.
       await ctx.db.patch(existing._id, { ...args, createdAt: existing.createdAt })
-      // EC-277: maintain the reference index in-transaction (AD-6). The live pin
-      // (`publishedVersion`) is preserved across an upsert, so a published doc keeps
-      // its published index rows in sync with its edited draft.
-      await maintainDocumentReferences(
-        ctx,
-        args.collection,
-        args.docId,
-        args.document as CmsDocument,
-        existing.publishedVersion !== undefined,
-      )
       return ctx.db.get(existing._id)
     }
     const id = await ctx.db.insert('cmsDocuments', args)
-    // EC-277: a freshly inserted document is draft-only (no live pin yet).
-    await maintainDocumentReferences(ctx, args.collection, args.docId, args.document as CmsDocument, false)
     return ctx.db.get(id)
   },
 })
@@ -91,8 +77,8 @@ export const deleteDocument = mutation({
       .withIndex('by_doc', (q) => q.eq('collection', args.collection).eq('docId', args.docId))
       .collect()
     for (const row of versions) await ctx.db.delete(row._id)
-    // EC-277: drop the deleted document's reference index rows in-transaction.
-    await removeDocumentReferences(ctx, args.collection, args.docId)
+    // EC-286: the write-chokepoint trigger drops this document's index rows (and
+    // revalidates if it was published) when the `cmsDocuments` delete commits.
   },
 })
 
@@ -170,16 +156,10 @@ export const publishDocumentVersion = mutation({
       .withIndex('by_doc', (q) => q.eq('collection', args.collection).eq('docId', args.docId))
       .first()
     if (!doc) return null
+    // EC-286: setting the live pin (`publishedVersion`) is a change the
+    // write-chokepoint trigger sees — it reindexes the published reference rows
+    // and fires host revalidation (EC-146 instant publish). No manual calls here.
     await ctx.db.patch(doc._id, { publishedVersion: args.version, updatedAt: args.updatedAt })
-    // EC-277: the doc now has a live pin — add its published index rows. Published
-    // entries are extracted from the live draft content (matching the EC-173 guard
-    // and `reindexDocumentReferences`), not the pinned snapshot.
-    await maintainDocumentReferences(ctx, args.collection, args.docId, doc.document as CmsDocument, true)
-    // EC-146 instant publish: a CONTENT publish must invalidate the host cache just
-    // like a graph publish — without this, instant-publish silently never fires for
-    // a content-only site (the server-side webhook path previously covered only
-    // `publishing:publish`). Fire-and-forget; unconfigured deployments no-op.
-    await scheduleRevalidate(ctx, 'documents.publish')
     return ctx.db.get(doc._id)
   },
 })
@@ -194,12 +174,9 @@ export const unpublishDocument = mutation({
       .first()
     if (!doc) return null
     // Convex patch removes a field set to `undefined` — clears the live pin.
+    // EC-286: clearing the pin is a change the write-chokepoint trigger sees — it
+    // drops the published index rows and revalidates the host. No manual calls.
     await ctx.db.patch(doc._id, { publishedVersion: undefined, updatedAt: args.updatedAt })
-    // EC-277: the live pin is cleared — drop this doc's published index rows.
-    await maintainDocumentReferences(ctx, args.collection, args.docId, doc.document as CmsDocument, false)
-    // EC-146 instant publish: unpublishing content must drop the host's cached
-    // pages too (the page that baked this doc now serves stale published content).
-    await scheduleRevalidate(ctx, 'documents.unpublish')
     return ctx.db.get(doc._id)
   },
 })

package/convex/content.ts

@@ -17,8 +17,6 @@ import type {
   Perspective,
 } from '@elytracms/core/content'
 import type { AssetRecord } from '@elytracms/core/persistence'
-import { parseProjectGraph } from '@elytracms/core/project-graph'
-import type { ProjectGraph } from '@elytracms/core/project-graph'
 import type { QueryCtx } from './functions'
 
 /**
@@ -68,10 +66,7 @@ const DEFAULT_LOCALES: LocaleConfig = { default: 'en', locales: ['en'] }
  * produced: CMS collections are config-owned (EC-183, AD-11) and supplied by the
  * caller (already validated), so there is no stored schema blob to reject.
  */
-export type ContentKitIssueCode =
-  | 'invalid-stored-schema'
-  | 'invalid-stored-document'
-  | 'invalid-stored-graph'
+export type ContentKitIssueCode = 'invalid-stored-schema' | 'invalid-stored-document'
 
 export interface ContentKitIssue {
   code: ContentKitIssueCode
@@ -221,44 +216,8 @@ export async function createContent(
     })
   }
 
-  // The page graph backs `resolvePage`'s page capability; it is only loaded
-  // when routes were provided (without routes, nothing can resolve to a page).
-  // Draft sees the latest revision; published sees the revision pinned to the
-  // publishing environment (EC-021 at the graph level).
-  let graph: ProjectGraph | null = null
-  if (routes.length > 0) {
-    let serialized: string | undefined
-    if (perspective === 'draft') {
-      const latest = await ctx.db
-        .query('graphRevisions')
-        .withIndex('by_revision')
-        .order('desc')
-        .first()
-      serialized = latest?.serializedGraph
-    } else {
-      const state = await ctx.db.query('publishingState').first()
-      const pinnedRevision = state?.status === 'published' ? state.publishedRevision : undefined
-      if (pinnedRevision !== undefined) {
-        const pinned = await ctx.db
-          .query('graphRevisions')
-          .withIndex('by_revision', (q) => q.eq('revision', pinnedRevision))
-          .first()
-        serialized = pinned?.serializedGraph
-      }
-    }
-    if (serialized !== undefined) {
-      const parsed = parseProjectGraph(serialized)
-      if (parsed.ok) {
-        graph = parsed.graph
-      } else {
-        loadIssues.push({
-          code: 'invalid-stored-graph',
-          message: `Stored graph revision for "${projectId}" (${perspective}) could not be parsed; pages are unavailable.`,
-          meta: { projectId, perspective },
-        })
-      }
-    }
-  }
+  // EC-287: there is no project graph. Pages are `page`-collection documents,
+  // resolved by `resolvePage` from the document lookup + routes — no graph load.
 
   // --- Index into the synchronous lookup the pure accessors read through ---
 

package/convex/delivery.ts

@@ -29,26 +29,19 @@ import { requireUserId } from './guard'
  *   function — the EC-224 *pinned version snapshot* (decoupled from the live,
  *   continuously-edited draft). Publish-ness is the version pointer alone;
  *   drafts and unpinned rows are never returned;
- * - the graph returned is ONLY the revision pinned by `publishingState` (the
- *   deployment's single environment) — the latest working revision is never exposed;
  * - nothing else draft-only exists in the payload (asset metadata has no draft
  *   variant). CMS collection schema AND routes/redirects are config-owned
  *   (EC-183/EC-207, AD-11) — the host reads them from its own config, not this
- *   snapshot.
+ *   snapshot. EC-287: there is no project graph — layouts/structure are code.
  *
- * `draftSnapshot` is the draft-perspective equivalent (latest graph revision,
- * all stored document rows including drafts) and is gated by the deployment
- * env var `DRAFT_PREVIEW_TOKEN` — set via `npx convex env set`. A missing or
+ * `draftSnapshot` is the draft-perspective equivalent (all stored document rows
+ * including drafts) and is gated by the deployment env var `DRAFT_PREVIEW_TOKEN`
+ * — set via `npx convex env set`. A missing or
  * mismatching token throws `unauthorized`; an unset env var closes the
  * endpoint entirely. The host server passes the token from its own env when
  * Next draft mode is enabled (itself gated by the host's preview token).
  */
 
-interface GraphRevisionPayload {
-  revision: number
-  serializedGraph: string
-}
-
 interface DeliverySnapshot {
   projectId: string
   perspective: 'published' | 'draft'
@@ -69,12 +62,6 @@ interface DeliverySnapshot {
   documents: unknown[]
   /** Asset metadata in the delivery `AssetRecord` shape (with serve URLs). */
   assets: unknown[]
-  /**
-   * Graph revisions per perspective. `snapshot` NEVER fills `draft` — only
-   * `draftSnapshot` does. `published` is the `publishingState`-pinned
-   * revision, or `null` when never published.
-   */
-  graphs: { draft: GraphRevisionPayload | null; published: GraphRevisionPayload | null }
 }
 
 /** One document per persisted source — must match the studio's sources-store. */
@@ -131,22 +118,6 @@ function dataSourcesFromSystemCollection(documents: unknown[]): unknown[] {
   return sources
 }
 
-async function loadPinnedGraph(ctx: QueryCtx): Promise<GraphRevisionPayload | null> {
-  const state = await ctx.db.query('publishingState').first()
-  const pinned = state?.status === 'published' ? state.publishedRevision : undefined
-  if (pinned === undefined) return null
-  const row = await ctx.db
-    .query('graphRevisions')
-    .withIndex('by_revision', (q) => q.eq('revision', pinned))
-    .first()
-  return row ? { revision: row.revision, serializedGraph: row.serializedGraph } : null
-}
-
-async function loadLatestGraph(ctx: QueryCtx): Promise<GraphRevisionPayload | null> {
-  const row = await ctx.db.query('graphRevisions').withIndex('by_revision').order('desc').first()
-  return row ? { revision: row.revision, serializedGraph: row.serializedGraph } : null
-}
-
 export async function loadSnapshot(
   ctx: QueryCtx,
   args: { projectId: string },
@@ -214,10 +185,6 @@ export async function loadSnapshot(
     })
   }
 
-  const published = await loadPinnedGraph(ctx)
-  // The latest working revision is loaded ONLY for the token-gated draft path.
-  const draft = perspective === 'draft' ? await loadLatestGraph(ctx) : null
-
   // LIVE-mode data sources: the builder's persisted source records, projected
   // to the delivery envelope (config only — see the helper's exposure rules).
   // Sources are project *config*, not perspective-gated content, so they are
@@ -234,7 +201,6 @@ export async function loadSnapshot(
     sources,
     documents,
     assets,
-    graphs: { draft, published },
   }
 }
 
@@ -249,8 +215,8 @@ export const snapshot = query({
 
 /**
  * Draft-perspective snapshot for token-holding preview hosts: all stored
- * document rows (drafts included) plus the latest working graph revision.
- * Gated by the `DRAFT_PREVIEW_TOKEN` deployment env var.
+ * document rows (drafts included). Gated by the `DRAFT_PREVIEW_TOKEN` deployment
+ * env var.
  */
 export const draftSnapshot = query({
   args: { projectId: v.string(), token: v.string() },
@@ -270,8 +236,8 @@ export const draftSnapshot = query({
  * EC-268: instant-publish configuration health for the studio UI. Returns ONLY
  * whether each delivery env var is set — never the values — so the studio can warn
  * when a publish would silently no-op. The pipeline gates on these: a publish only
- * schedules the webhook when `CANVAS_PROJECT_SCOPE` is set (`publishing.ts`
- * `scheduleRevalidate`), and the webhook only fires when
+ * schedules the webhook when `CANVAS_PROJECT_SCOPE` is set (the write-chokepoint
+ * trigger's `scheduleRevalidate`, `triggers.ts`), and the webhook only fires when
  * `CANVAS_REVALIDATE_ENDPOINT` + `CANVAS_REVALIDATE_SECRET` are set
  * (`webhooks.ts` `deliver`). A future `elytra doctor` (EC-259) can read the same
  * query. Gated to authenticated users — config state is not public.

package/convex/functions.ts

@@ -1,3 +1,4 @@
+import { customCtx, customMutation } from 'convex-helpers/server/customFunctions'
 import {
   httpActionGeneric,
   internalMutationGeneric,
@@ -13,6 +14,7 @@ import type {
   QueryBuilder,
 } from 'convex/server'
 import schema from './schema'
+import { triggers } from './triggers'
 
 /**
  * Typed function builders bound to our schema's data model. This is what Convex
@@ -25,9 +27,22 @@ export type QueryCtx = GenericQueryCtx<DataModel>
 export type MutationCtx = GenericMutationCtx<DataModel>
 
 export const query = queryGeneric as QueryBuilder<DataModel, 'public'>
-export const mutation = mutationGeneric as MutationBuilder<DataModel, 'public'>
+/**
+ * EC-286: every mutation runs through the write-chokepoint triggers (`triggers.ts`)
+ * via `customCtx(triggers.wrapDB)`, so reference-index maintenance and host
+ * revalidation derive by construction on any `cmsDocuments` write — no mutation
+ * calls a derivation helper by hand. (EC-287 retired the graph publish path, so
+ * `cmsDocuments` is the single trigger.)
+ */
+export const mutation = customMutation(
+  mutationGeneric as MutationBuilder<DataModel, 'public'>,
+  customCtx(triggers.wrapDB),
+)
 /** CLI-/scheduler-only functions (e.g. seeding) — not callable by clients (EC-150). */
-export const internalMutation = internalMutationGeneric as MutationBuilder<DataModel, 'internal'>
+export const internalMutation = customMutation(
+  internalMutationGeneric as MutationBuilder<DataModel, 'internal'>,
+  customCtx(triggers.wrapDB),
+)
 /** Server-only reads (e.g. the EC-157 HTTP sync endpoints) — not callable by clients. */
 export const internalQuery = internalQueryGeneric as QueryBuilder<DataModel, 'internal'>
 /** HTTP action builder (EC-252) — used by the package's `http.ts`/`sync.ts`. Not

package/convex/members.ts

@@ -39,8 +39,8 @@ export const get = query({
  * The authenticated caller's membership on this deployment (studio bootstrap).
  *
  * Soft-guarded (EC-279): this is the studio's pre-sign-in connectivity probe
- * (`ConvexProjectRepository.status`) and role-badge read, fired before a session
- * exists. Returning `null` for the unauthenticated state — instead of throwing
+ * and role-badge read, fired before a session exists. Returning `null` for the
+ * unauthenticated state — instead of throwing
  * `requireUserId` — keeps the normal boot quiet (a thrown handler is logged by
  * Convex as a scary `Uncaught Error: unauthorized` even though the client
  * catches it). A non-throwing probe still proves the backend answered, so

package/convex/referenceMaintenance.ts

@@ -1,8 +1,7 @@
 import { documentKey } from '@elytracms/core/cms-core'
 import type { CmsDocument } from '@elytracms/core/cms-core'
-import { extractReferences, extractSelfTypedGraphReferences } from '@elytracms/core/persistence'
+import { extractReferences } from '@elytracms/core/persistence'
 import type { OutboundReference } from '@elytracms/core/persistence'
-import { parseProjectGraph } from '@elytracms/core/project-graph'
 import type { MutationCtx } from './functions'
 
 /**
@@ -22,15 +21,12 @@ import type { MutationCtx } from './functions'
  * which is exactly what lets the identical walk run here, in the Convex isolate,
  * that runs in the studio and the in-memory adapter.
  *
- * Mirrors `reindexDocumentReferences` / `reindexGraph*References`
- * (`@elytracms/core/persistence`), but writes through `ctx.db` rather than the adapter.
+ * Mirrors `reindexDocumentReferences` (`@elytracms/core/persistence`), but writes
+ * through `ctx.db` rather than the adapter. EC-287: the project graph and its
+ * publish path are retired, so document writes are the only index source.
  */
 
 type Variant = 'draft' | 'published'
-type GraphSourceType = 'page' | 'layout'
-
-/** The graph (EC-187) is layouts-only; pages live in the `page` collection's body. */
-const GRAPH_SOURCE_TYPES: readonly GraphSourceType[] = ['page', 'layout']
 
 interface ReferenceRow {
   path: string
@@ -54,21 +50,6 @@ async function deleteDocumentSource(ctx: MutationCtx, variant: Variant, sourceId
   for (const row of existing) await ctx.db.delete(row._id)
 }
 
-/** Delete every index row held by the given source types in one variant (graph recompute). */
-async function deleteSourceTypes(
-  ctx: MutationCtx,
-  variant: Variant,
-  sourceTypes: readonly GraphSourceType[],
-): Promise<void> {
-  for (const sourceType of sourceTypes) {
-    const existing = await ctx.db
-      .query('referenceEntries')
-      .withIndex('by_source', (q) => q.eq('variant', variant).eq('sourceType', sourceType))
-      .collect()
-    for (const row of existing) await ctx.db.delete(row._id)
-  }
-}
-
 /**
  * Recompute a document's index rows in-transaction (replace-all-for-source). The
  * editable content IS the draft, so a document always (re)indexes its draft rows;
@@ -111,53 +92,3 @@ export async function removeDocumentReferences(
   await deleteDocumentSource(ctx, 'draft', sourceId)
   await deleteDocumentSource(ctx, 'published', sourceId)
 }
-
-/** Recompute the draft graph rows from a just-saved revision's serialized graph. */
-export async function maintainGraphDraftReferences(
-  ctx: MutationCtx,
-  serializedGraph: string,
-): Promise<void> {
-  const parsed = parseProjectGraph(serializedGraph)
-  await deleteSourceTypes(ctx, 'draft', GRAPH_SOURCE_TYPES)
-  if (!parsed.ok) return // a malformed stored graph contributes no entries (it can't render either)
-  for (const entry of extractSelfTypedGraphReferences(parsed.graph)) {
-    await ctx.db.insert('referenceEntries', {
-      variant: 'draft',
-      sourceType: entry.source.type as GraphSourceType,
-      sourceId: entry.source.id,
-      path: entry.path,
-      targetType: entry.target.type,
-      targetId: entry.target.id,
-      kind: entry.kind,
-    })
-  }
-}
-
-/**
- * Recompute the published graph rows from the revision currently pinned live by the
- * publishing state (single-environment, EC-179). Unpublishing drops them all.
- */
-export async function maintainGraphPublishedReferences(ctx: MutationCtx): Promise<void> {
-  await deleteSourceTypes(ctx, 'published', GRAPH_SOURCE_TYPES)
-  const state = await ctx.db.query('publishingState').first()
-  if (!state || state.status !== 'published' || state.publishedRevision === undefined) return
-  const publishedRevision = state.publishedRevision
-  const revision = await ctx.db
-    .query('graphRevisions')
-    .withIndex('by_revision', (q) => q.eq('revision', publishedRevision))
-    .first()
-  if (!revision) return
-  const parsed = parseProjectGraph(revision.serializedGraph)
-  if (!parsed.ok) return
-  for (const entry of extractSelfTypedGraphReferences(parsed.graph)) {
-    await ctx.db.insert('referenceEntries', {
-      variant: 'published',
-      sourceType: entry.source.type as GraphSourceType,
-      sourceId: entry.source.id,
-      path: entry.path,
-      targetType: entry.target.type,
-      targetId: entry.target.id,
-      kind: entry.kind,
-    })
-  }
-}

package/convex/references.ts

@@ -10,7 +10,9 @@ import type { MutationCtx } from './functions'
  */
 
 const variantValidator = v.union(v.literal('draft'), v.literal('published'))
-const sourceTypeValidator = v.union(v.literal('document'), v.literal('page'), v.literal('layout'))
+// EC-287: structure is code — the only reference source is a CMS document. The
+// retired graph's `page`/`layout` sources no longer exist.
+const sourceTypeValidator = v.literal('document')
 const targetTypeValidator = v.union(
   v.literal('document'),
   v.literal('component'),
@@ -38,7 +40,7 @@ const entryValidator = v.object({
 async function deleteForSource(
   ctx: MutationCtx,
   variant: 'draft' | 'published',
-  sourceType: 'document' | 'page' | 'layout',
+  sourceType: 'document',
   sourceId?: string,
 ): Promise<void> {
   const existing = await ctx.db

package/convex/schema.ts

@@ -24,9 +24,13 @@ import { authTables } from '@convex-dev/auth/server'
  * the repo registry (EC-181), project identity/settings/locales/routes and CMS
  * **collection schemas** all live in `elytra.config.ts` (EC-182/EC-183). So
  * there is no `projects`, `componentManifests`, or `cmsSchemas` table — the
- * remaining tables hold **data only**: CMS documents, assets, graph revisions
- * (the page composition is a field value — data, per AD-12), publishing state,
- * the derived reference index, deployment membership, CLI tokens, and auth.
+ * remaining tables hold **data only**: CMS documents, assets, the derived
+ * reference index, deployment membership, CLI tokens, and auth.
+ *
+ * EC-287: the project graph + its publish path are RETIRED (structure is code; a
+ * page renders its `body` composition directly, published per document via
+ * `cmsDocuments.publishedVersion`). The `graphRevisions` + `publishingState` tables
+ * are gone, and a reference source is only ever a `document`.
  *
  * This schema is provider configuration only — the Studio and tests talk to the
  * provider-neutral `PersistenceAdapter`, never to Convex directly (brief §4.10).
@@ -74,16 +78,6 @@ export default defineSchema({
     .index('by_token', ['tokenId'])
     .index('by_hash', ['tokenHash']),
 
-  /** Project graph revision records — append-only (EC-041). */
-  graphRevisions: defineTable({
-    revision: v.number(),
-    serializedGraph: v.string(),
-    schemaVersion: v.number(),
-    label: v.optional(v.string()),
-    message: v.optional(v.string()),
-    createdAt: v.string(),
-  }).index('by_revision', ['revision']),
-
   /**
    * CMS documents (EC-043). The stored `document` is the continuous working
    * **draft**; `publishedVersion` pins which `documentVersions` row is live
@@ -102,10 +96,10 @@ export default defineSchema({
     .index('by_doc', ['collection', 'docId']),
 
   /**
-   * CMS document version snapshots — append-only (EC-224), the document-scoped
-   * analogue of `graphRevisions`. One row per recorded version (created on
-   * publish or a pre-restore snapshot, never on a plain draft edit), keyed per
-   * document via `by_doc`. `cmsDocuments.publishedVersion` points at the live one.
+   * CMS document version snapshots — append-only (EC-224). One row per recorded
+   * version (created on publish or a pre-restore snapshot, never on a plain draft
+   * edit), keyed per document via `by_doc`. `cmsDocuments.publishedVersion` points
+   * at the live one.
    */
   documentVersions: defineTable({
     collection: v.string(),
@@ -144,7 +138,8 @@ export default defineSchema({
    */
   referenceEntries: defineTable({
     variant: v.union(v.literal('draft'), v.literal('published')),
-    sourceType: v.union(v.literal('document'), v.literal('page'), v.literal('layout')),
+    // EC-287: structure is code — the only reference source is a CMS document.
+    sourceType: v.literal('document'),
     sourceId: v.string(),
     /** Exact field/node path inside the source, e.g. `values/author`. */
     path: v.string(),
@@ -153,33 +148,18 @@ export default defineSchema({
     /** Which reference-bearing structure produced the entry. */
     kind: v.string(),
   })
-    // `by_source` also serves source-type prefix scans (the graph recompute path).
     .index('by_source', ['variant', 'sourceType', 'sourceId'])
     .index('by_target', ['targetType', 'targetId', 'variant']),
 
   /**
    * Reference-index build marker (EC-269). Single-row (a deployment IS one
-   * project, like `publishingState`): present once a backfill has fully rebuilt
-   * the index. Its presence lets the studio skip the (clear + rebuild) backfill
-   * on the read path — maintained-on-write keeps the index current thereafter —
-   * so opening the References panel issues zero mutations.
+   * project): present once a backfill has fully rebuilt the index. Its presence
+   * lets the studio skip the (clear + rebuild) backfill on the read path —
+   * maintained-on-write keeps the index current thereafter — so opening the
+   * References panel issues zero mutations.
    */
   referenceIndexMarker: defineTable({
     /** Entry count produced by the completing backfill (diagnostic only). */
     entryCount: v.number(),
   }),
-
-  /**
-   * Publishing state (EC-045). Single-environment (EC-179, vision AD-8): a
-   * deployment IS one environment, so this is a single-row table — no
-   * `environment`, no index.
-   */
-  publishingState: defineTable({
-    status: v.union(v.literal('draft'), v.literal('published')),
-    publishedRevisionId: v.optional(v.string()),
-    publishedRevision: v.optional(v.number()),
-    publishedAt: v.optional(v.string()),
-    createdAt: v.string(),
-    updatedAt: v.string(),
-  }),
 })

package/convex/sync.ts

@@ -5,7 +5,6 @@ import { verifyCliToken } from '@elytracms/core/operations'
 import type { VerifiedCliToken } from '@elytracms/core/operations'
 import type { CliTokenRepository, PersistenceAdapter } from '@elytracms/core/persistence'
 import { httpAction, internalQuery } from './functions'
-import type { QueryCtx } from './functions'
 import type { ProjectRole } from './guard'
 
 /**
@@ -15,9 +14,9 @@ import type { ProjectRole } from './guard'
  * the real builder instead of a `fetchImpl` double:
  *
  * - `GET  /api/projects/:projectId/registry-sync/snapshot?mode=&environment=` — the
- *   typegen/check snapshot: locale config and the graph revision for the requested
- *   mode. Collection schemas and routes/redirects are config-owned (EC-183/EC-207,
- *   AD-11) — the CLI reads them from `elytra.config.ts`, not this snapshot.
+ *   typegen/check snapshot: locale config only. Collection schemas, routes/redirects,
+ *   AND the project graph are config-owned (EC-183/EC-207/EC-287, AD-11) — the CLI
+ *   reads them from `elytra.config.ts`, not this snapshot.
  *
  * ## Package-shipped, deployment-agnostic (EC-223/EC-252)
  *
@@ -248,11 +247,6 @@ export const registrySync = httpAction(async (ctx, request) => {
 
 type SnapshotMode = 'published' | 'draft'
 
-interface GraphRevisionPayload {
-  revision: number
-  serializedGraph: string
-}
-
 interface BuilderSnapshot {
   projectId: string
   mode: SnapshotMode
@@ -260,36 +254,14 @@ interface BuilderSnapshot {
   project: null
   localeConfig: { default: string; locales: string[] }
   collections: never[]
-  graph: GraphRevisionPayload | null
-}
-
-/** The publishing-state-pinned revision (single-environment; mirrors `delivery.ts`). */
-async function loadPinnedGraph(ctx: QueryCtx): Promise<GraphRevisionPayload | null> {
-  const state = await ctx.db.query('publishingState').first()
-  const pinned = state?.status === 'published' ? state.publishedRevision : undefined
-  if (pinned === undefined) return null
-  const row = await ctx.db
-    .query('graphRevisions')
-    .withIndex('by_revision', (q) => q.eq('revision', pinned))
-    .first()
-  return row ? { revision: row.revision, serializedGraph: row.serializedGraph } : null
-}
-
-async function loadLatestGraph(ctx: QueryCtx): Promise<GraphRevisionPayload | null> {
-  const row = await ctx.db
-    .query('graphRevisions')
-    .withIndex('by_revision')
-    .order('desc')
-    .first()
-  return row ? { revision: row.revision, serializedGraph: row.serializedGraph } : null
 }
 
 /**
  * Everything `builder typegen`/`builder check` need from live builder state, in the
  * `BuilderSnapshot` wire shape of `@elytracms/core/export-sync`'s `createHttpBuilderSource`.
- * Unlike `delivery:snapshot` this is token-gated and serves exactly one graph per
- * request: published = the pinned revision for `environment`, draft = latest.
- * Component manifests are code-owned, so the snapshot no longer carries them.
+ * EC-287: the project graph is retired (structure is code), so the snapshot no
+ * longer carries a graph — like the CMS schema and routes, it is config-owned and
+ * read from `elytra.config.ts` in the consuming repo.
  */
 export const exportSnapshot = internalQuery({
   args: {
@@ -299,16 +271,13 @@ export const exportSnapshot = internalQuery({
   },
   handler: async (ctx, { projectId, mode, environment }): Promise<BuilderSnapshot> => {
     // `environment` is a vestigial wire-compat field on the CLI snapshot contract
-    // (EC-179 §2): a deployment IS one environment, so the pinned read is single-row.
-    const graph = mode === 'published' ? await loadPinnedGraph(ctx) : await loadLatestGraph(ctx)
-
+    // (EC-179 §2): a deployment IS one environment.
     // AD-11 (EC-182/EC-183/EC-207): project identity, locale config, CMS
     // collection schemas, AND routes/redirects are all config-owned —
     // `builder typegen`/`check` run in the consuming repo and read them from
-    // `elytra.config.ts`, not the wire. The DB carries only data (documents,
-    // assets, graph). `project`/`localeConfig`/`collections` stay in the wire
-    // shape as config-sourced placeholders until the CLI reads config directly
-    // (C1) — the snapshot no longer carries a schema or a route table to return.
+    // `elytra.config.ts`, not the wire. `project`/`localeConfig`/`collections`
+    // stay in the wire shape as config-sourced placeholders until the CLI reads
+    // config directly (C1).
     return {
       projectId,
       mode,
@@ -316,7 +285,6 @@ export const exportSnapshot = internalQuery({
       project: null,
       localeConfig: { default: 'en', locales: ['en'] },
       collections: [],
-      graph,
     }
   },
 })