@elytracms/studio 0.0.86 → 0.0.87

package/convex/rail-write-parity.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from 'vitest'
+import { convexTest } from 'convex-test'
+import { makeFunctionReference } from 'convex/server'
+import type { ConvexHttpClient } from 'convex/browser'
+import type { FunctionReference } from 'convex/server'
+import { InMemoryPersistenceAdapter } from '@elytracms/core/persistence'
+import type { PersistenceAdapter } from '@elytracms/core/persistence'
+import { ConvexPersistenceAdapter } from '../src/lib/persistence/convex-adapter'
+import { updateAssetMetadata } from '../src/components/assets/asset-metadata'
+import { runVariantBackfill } from '../src/lib/assets/backfill-thumbs'
+import schema from './schema'
+
+/**
+ * EC-577 — the studio's REAL asset writers against BOTH adapters.
+ *
+ * The contract scenarios (`contract-scenarios.ts`, run by `contract-parity.test.ts`)
+ * pin the adapter write rule itself. This file pins the writers on top of it —
+ * the metadata dialog's `updateAssetMetadata` and the "Generate previews"
+ * backfill — because the reported loss happened between the two: the writer
+ * expressed a clear as an omitted key and restated everything else, and the two
+ * adapters read that one write in opposite ways. Measured on 162174ce with the
+ * same writer calls:
+ *
+ *   in-memory: {"focalPoint":null,"alt":null,"thumb":null,"lqip":null}
+ *   convex   : {"focalPoint":{"x":0.2,"y":0.8},"alt":"Harbour","thumb":{…},"lqip":"data:…"}
+ *
+ * i.e. the playground lost the previews and connected mode never cleared.
+ */
+
+const modules = {
+  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
+  './_generated/api.ts': async () => ({}),
+}
+
+const PROJECT_ID = 'rail-write-parity'
+const SESSION_USER_ID = 'user_admin'
+
+async function convexBackend() {
+  const t = convexTest(schema, modules)
+  const now = new Date().toISOString()
+  await t.run(async (ctx) => {
+    await ctx.db.insert('members', { userId: SESSION_USER_ID, role: 'admin', createdAt: now, updatedAt: now })
+  })
+  const asAdmin = t.withIdentity({ subject: SESSION_USER_ID, issuer: 'https://convex.test' })
+  const client = {
+    query: (ref: FunctionReference<'query'>, args?: Record<string, unknown>) => asAdmin.query(ref, args ?? {}),
+    mutation: (ref: FunctionReference<'mutation'>, args?: Record<string, unknown>) => asAdmin.mutation(ref, args ?? {}),
+  } as unknown as ConvexHttpClient
+  return { t, adapter: new ConvexPersistenceAdapter(client, PROJECT_ID, []) }
+}
+
+const THUMB = { storageKey: 'blob_thumb', url: 'https://cdn.test/t.webp', width: 480, height: 240 }
+const LQIP = 'data:image/webp;base64,AAAA'
+
+async function seedHero(adapter: PersistenceAdapter) {
+  await adapter.assets.upsertAsset(PROJECT_ID, {
+    id: 'asset_hero',
+    filename: 'hero.jpg',
+    contentType: 'image/jpeg',
+    byteSize: 10,
+    width: 4000,
+    height: 2000,
+    alt: 'Harbour',
+    title: 'Hero',
+    focalPoint: { x: 0.2, y: 0.8 },
+    thumb: THUMB,
+    lqip: LQIP,
+    meta: { alt: 'Harbour', legacyKey: 'kept' },
+  })
+}
+
+/** "Reset to centre", then clear alt — the two connected clears that never persisted. */
+async function metadataClears(adapter: PersistenceAdapter) {
+  await seedHero(adapter)
+  const assets = adapter.assets
+  const reset = await updateAssetMetadata({ assets }, PROJECT_ID, 'asset_hero', { focalPoint: null })
+  const clearedAlt = await updateAssetMetadata({ assets }, PROJECT_ID, 'asset_hero', { alt: '' })
+  expect([reset.ok, clearedAlt.ok]).toEqual([true, true])
+  const after = await adapter.assets.getAsset(PROJECT_ID, 'asset_hero')
+  return {
+    focalPoint: after.focalPoint ?? null,
+    alt: after.alt ?? null,
+    title: after.title ?? null,
+    thumb: after.thumb ?? null,
+    lqip: after.lqip ?? null,
+    meta: after.meta ?? null,
+  }
+}
+
+describe('EC-577 — the asset writers mean the same thing on both adapters', () => {
+  it('a metadata clear clears, and keeps thumb/lqip/meta, in the playground AND connected', async () => {
+    const memory = await metadataClears(new InMemoryPersistenceAdapter())
+    const convex = await metadataClears((await convexBackend()).adapter)
+    const expected = {
+      focalPoint: null,
+      alt: null,
+      title: 'Hero',
+      thumb: THUMB,
+      lqip: LQIP,
+      meta: { alt: 'Harbour', legacyKey: 'kept' },
+    }
+    expect({ memory, convex }).toEqual({ memory: expected, convex: expected })
+  })
+
+  it('a metadata write to a deleted asset is refused, never re-creates it', async () => {
+    for (const adapter of [new InMemoryPersistenceAdapter(), (await convexBackend()).adapter]) {
+      const result = await updateAssetMetadata({ assets: adapter.assets }, PROJECT_ID, 'asset_gone', {
+        focalPoint: { x: 0.5, y: 0.5 },
+      })
+      expect(result.ok).toBe(false)
+      if (!result.ok) expect(result.message).toContain('No asset “asset_gone” is stored')
+      expect(await adapter.assets.findAsset(PROJECT_ID, 'asset_gone')).toBeUndefined()
+    }
+  })
+
+  it('the preview backfill writes only the variants: an alt saved mid-run survives', async () => {
+    for (const adapter of [new InMemoryPersistenceAdapter(), (await convexBackend()).adapter]) {
+      await adapter.assets.upsertAsset(PROJECT_ID, {
+        id: 'asset_big',
+        filename: 'big.jpg',
+        contentType: 'image/jpeg',
+        byteSize: 10,
+        width: 4000,
+        height: 3000,
+        storageKey: 'blob_big',
+      })
+      const blobs = {
+        async get() {
+          // An editor saves alt while the backfill is fetching this original — the
+          // backfill's write lands after it, from a listing taken before it.
+          await updateAssetMetadata({ assets: adapter.assets }, PROJECT_ID, 'asset_big', { alt: 'Mid-run alt' })
+          return new Uint8Array([1])
+        },
+      }
+      const progress = await runVariantBackfill(
+        {
+          assets: adapter.assets,
+          blobs: blobs as never,
+          generate: async () => ({ thumb: THUMB, lqip: LQIP }),
+        },
+        PROJECT_ID,
+      )
+      expect(progress.generated).toBe(1)
+      const after = await adapter.assets.getAsset(PROJECT_ID, 'asset_big')
+      expect([after.alt, after.thumb, after.lqip]).toEqual(['Mid-run alt', THUMB, LQIP])
+    }
+  })
+})
+
+describe('EC-577 (D13/F24) — the one asset row → record projection on the Convex delivery route', () => {
+  // EC-574 deleted the second route (the `createContent` kit); the snapshot is the
+  // remaining reader of the projection, and this pins the delivery cut it serves.
+  it('delivery:snapshot delivers the asset with its lqip and without editorial columns', async () => {
+    const { t, adapter } = await convexBackend()
+    await adapter.assets.upsertAsset(PROJECT_ID, {
+      id: 'asset_p',
+      filename: 'p.png',
+      contentType: 'image/png',
+      byteSize: 1,
+      url: 'https://assets.test/p.png',
+      title: 'Library title',
+      thumb: THUMB,
+      lqip: LQIP,
+    })
+    await adapter.cms.upsertDocument(PROJECT_ID, {
+      collection: 'post',
+      id: 'one',
+      values: { cover: { type: 'asset', id: 'asset_p' } },
+    })
+    const snapshot = (await t.query(makeFunctionReference<'query'>('delivery:snapshot'), {
+      projectId: PROJECT_ID,
+    })) as { assets: Record<string, unknown>[] }
+    // The snapshot is the positive control: it always carried the lqip.
+    expect(snapshot.assets[0]?.lqip).toBe(LQIP)
+    // Editorial-only columns stay off the delivery wire (EC-400 thumb; the library title).
+    expect(snapshot.assets[0]).not.toHaveProperty('thumb')
+    expect(snapshot.assets[0]).not.toHaveProperty('title')
+    expect(snapshot.assets[0]).toMatchObject({ url: 'https://assets.test/p.png' })
+  })
+})

package/convex/redirects.ts

@@ -1,7 +1,12 @@
-import { v } from 'convex/values'
+import { ConvexError, v } from 'convex/values'
+import type { DocumentByName, WithoutSystemFields } from 'convex/server'
+import { redirectRowSchema, rejectedWriteMessage, resolveRecordWrite } from '@elytracms/core/persistence'
+import type { DataModel } from './functions'
 import { mutation, query } from './functions'
 import { requireCapability } from './guard'
 
+type RedirectDoc = DocumentByName<DataModel, 'redirects'>
+
 /**
  * Editorial redirects persistence (EC-303). Redirects are data an editor owns —
  * saved+enabled entries go live dynamically (no deploy) via the delivery
@@ -10,30 +15,47 @@ import { requireCapability } from './guard'
  * are content, not administration.
  */
 
+/**
+ * Create or modify a redirect (EC-577). The ONE write rule (`resolveRecordWrite`,
+ * shared with the in-memory adapter) runs here, inside the transaction: a column
+ * absent from the args keeps its stored value — `permanent`/`enabled` included,
+ * whose defaults (the record schema's `.default(true)`) apply only when this save
+ * creates the redirect — `null` clears the optional `meta` bag, a value sets. ONE
+ * `db.patch` or ONE `db.insert`, so the EC-510 revalidation trigger fires once.
+ */
 export const save = mutation({
   args: {
     redirectId: v.string(),
-    from: v.string(),
-    to: v.string(),
-    permanent: v.boolean(),
-    enabled: v.boolean(),
-    // Schema-driven additive-field bag (EC-311 Tier 2). Absent on a save leaves the
-    // stored bag untouched (Convex `patch` only writes provided fields).
+    from: v.optional(v.string()),
+    to: v.optional(v.string()),
+    permanent: v.optional(v.boolean()),
+    enabled: v.optional(v.boolean()),
+    // Schema-driven additive-field bag (EC-311 Tier 2): present replaces the bag,
+    // `null` clears it, absent keeps it.
     meta: v.optional(v.any()),
     createdAt: v.string(),
     updatedAt: v.string(),
   },
-  handler: async (ctx, args) => {
+  handler: async (ctx, { redirectId, createdAt, updatedAt, ...write }) => {
     await requireCapability(ctx, 'content.write')
     const existing = await ctx.db
       .query('redirects')
-      .withIndex('by_redirect', (q) => q.eq('redirectId', args.redirectId))
+      .withIndex('by_redirect', (q) => q.eq('redirectId', redirectId))
       .first()
+    const resolved = resolveRecordWrite(redirectRowSchema, existing ?? undefined, write)
+    if (!resolved.ok) {
+      throw new ConvexError({
+        code: 'validation',
+        message: rejectedWriteMessage('redirect', redirectId, resolved.issues),
+        issues: resolved.issues,
+      })
+    }
     if (existing) {
-      await ctx.db.patch(existing._id, { ...args, createdAt: existing.createdAt })
+      await ctx.db.patch(existing._id, { ...(resolved.patch as Partial<RedirectDoc>), updatedAt })
       return ctx.db.get(existing._id)
     }
-    const id = await ctx.db.insert('redirects', args)
+    const row: WithoutSystemFields<RedirectDoc> = { ...resolved.row, redirectId, createdAt, updatedAt }
+    const id = await ctx.db.insert('redirects', row)
     return ctx.db.get(id)
   },
 })

package/convex/revalidate.ts

@@ -19,17 +19,19 @@ const webhooksDeliver = makeFunctionReference<'action'>('webhooks:deliver')
  * var. An unconfigured deployment (local dev, no env) is a silent no-op —
  * publishing must never depend on a reachable host.
  *
- * Called from the EC-286 write-chokepoint triggers only (`triggers.ts`), so
- * every writer of a live-wire table is covered by construction: `cmsDocuments`
- * when the published pin moves, and `redirects` on any write (EC-510 — a
- * saved+enabled redirect IS the live state, with no draft/published split).
+ * Called from the EC-286 write-chokepoint triggers only, so every writer of a
+ * live-wire table is covered by construction. Which tables, and which of their
+ * writes, is declared once — in `triggers.ts`, not here.
  *
  * Doc/collection-scoped tags (matching the client dispatcher's
  * `webhookTagsForEvent`) would be more surgical for DOCUMENTS, but need the
  * project locales — not available in the Convex env here. The sweep is the
  * honest, reliable v1; threading scoped tags is a precision follow-up. For
  * redirects the sweep is not a compromise but the correct answer — see
- * `ROUTING_OPERATIONS` in `src/lib/webhooks/tags.ts`.
+ * `ROUTING_OPERATIONS` in `src/lib/webhooks/tags.ts`. For assets it is the only
+ * correct answer today: a page reading an asset through a document asset field
+ * carries no `asset:<id>` tag (EC-566 D16), so the per-asset tag the browser
+ * dispatcher emits would miss it.
  */
 export async function scheduleRevalidate(ctx: MutationCtx, event: string): Promise<void> {
   const env =

package/convex/triggers.ts

@@ -23,9 +23,22 @@ import { scheduleRevalidate } from './revalidate'
  *
  * EC-287 retired the DB-resident project graph and its publish path, so
  * `cmsDocuments` is the SINGLE document trigger — one publish path, the
- * dual-path footgun gone at the source. EC-510 added `redirects`, the other
- * table whose rows go straight onto the live wire; both are registered here so
- * "which writes reach the host" has one place to read.
+ * dual-path footgun gone at the source.
+ *
+ * **Which writes reach the host** — every table the delivery snapshot
+ * (`delivery.ts`) projects onto the live wire is registered here, and nowhere
+ * else decides it:
+ *
+ * - `cmsDocuments` — only when the live pin (`publishedVersion`) moves;
+ * - `redirects` (EC-510) — every write (the row IS the live state);
+ * - `assets` (EC-579) — every edit and delete; a create fires nothing.
+ *
+ * The snapshot reads one more table, `documentVersions`, but only the version a
+ * `cmsDocuments` row pins — version rows are insert-only (`cms.ts`) and deleted
+ * only with their document, so they reach the wire through a pin move and need
+ * no trigger of their own. The rest (`members`, `invites`, `authorityAudit`,
+ * `referenceEntries`, `referenceIndexMarker`, the auth tables) never reach the
+ * wire. A table the snapshot starts projecting belongs in the list above.
  */
 export const triggers = new Triggers<DataModel>()
 
@@ -92,3 +105,40 @@ triggers.register('cmsDocuments', async (ctx, change) => {
 triggers.register('redirects', async (ctx, change) => {
   await scheduleRevalidate(ctx, change.operation === 'delete' ? 'redirects.remove' : 'redirects.save')
 })
+
+/**
+ * Asset records (EC-579). The delivery snapshot projects every asset row onto
+ * the live wire field by field (url, dimensions, alt, focal point, lqip, the
+ * `meta` bag), and like a redirect there is no draft/published split: an alt,
+ * focal-point or re-upload edit IS live output the moment it commits. Before
+ * this, the only emitter for an asset edit was the studio's browser dispatcher
+ * (`src/lib/webhooks`, active only when the studio bundle carries
+ * `VITE_REVALIDATE_*`), so a deployment revalidating through this server path
+ * alone — and any writer other than that browser — changed the live site
+ * without the host ever hearing of it (EC-566 M5; measured by the Codex
+ * review, P07).
+ *
+ * - **Update / delete → the whole-project sweep.** Not `asset:<id>`: the host
+ *   stamps that tag only on assets a page bakes through its composition, rich
+ *   text or OG image (`scopeAssetsToPage` in `@elytracms/next` `route-core.ts`);
+ *   an asset read through a document asset FIELD puts no tag on the page, so a
+ *   per-asset tag would leave exactly those pages stale (EC-566 D16 / Codex F14).
+ *   The sweep tag is on every cache entry, so it is correct by construction.
+ * - **Insert → nothing.** A brand-new asset id appears on no page yet — the
+ *   same rule the browser dispatcher applies to an `assets.upsert` create.
+ *
+ * Every update fires, including one that changed nothing on the wire (the
+ * editorial-only `thumb` variant, or a no-op re-save): the trigger cannot
+ * cheaply prove the delivery projection unchanged, and deciding it here would
+ * be a second declaration of which asset fields ride the wire (`delivery.ts`
+ * owns that). Asset saves are explicit actions — the detail surface's Save,
+ * the options dialog's close, a focal-point release — not keystrokes; the one
+ * bulk writer is the rail's "Generate previews" backfill, one sweep per asset.
+ *
+ * The event names are the operation names (`assets.upsert` / `assets.remove`),
+ * matching what the browser dispatcher carries for the same writes.
+ */
+triggers.register('assets', async (ctx, change) => {
+  if (change.operation === 'insert') return
+  await scheduleRevalidate(ctx, change.operation === 'delete' ? 'assets.remove' : 'assets.upsert')
+})

package/dist/components/app-views/default-modules.d.ts

@@ -2,7 +2,6 @@ import type { ReactNode } from 'react';
 import type { LucideIcon } from 'lucide-react';
 import type { CmsDocument, CollectionDef, CollectionFieldOverride, CollectionFormMeta, LocaleConfig } from '@elytracms/core/cms-core';
 import type { CustomizationIssue, Project, SectionId } from '@elytracms/core/studio-core';
-import type { InstantiatedKit } from '@elytracms/core/starter-kits';
 import type { HydratedCms } from '@elytracms/studio/lib/operations';
 import { type AppViewContext, type AppViewDeepLink, type AppViewModule, type NavPermission, type SidebarViewNode } from './module.js';
 /**
@@ -81,7 +80,7 @@ export interface RedirectsViewConfig extends BuiltinViewConfig {
  * different in kind: redirects' base is an engine-owned, fixed `CollectionDef`
  * known at config-build time; the assets base is the DEPLOYMENT's own
  * `kind:'asset'` collection (a project's `cms/collections/asset.ts`), only
- * knowable once the deployment resolves (hydrated session → kit → playground
+ * knowable once the deployment resolves (hydrated session → playground
  * config — see {@link resolveAssetsSchema}). So the merge runs at RENDER time
  * (inside `assetsView`'s `CmsSessionGate`), not at `nav.assets(config)` call
  * time: a locked-violation override (e.g. changing a declared field's type)
@@ -162,7 +161,7 @@ export declare function componentsView(config?: BuiltinViewConfig): AppViewModul
 export declare function redirectsView(config?: RedirectsViewConfig): AppViewModule;
 /**
  * Resolve the assets rail's EFFECTIVE schema (EC-319/EC-311): the deployment's
- * OWN `kind:'asset'` collection — hydrated session → kit → playground config,
+ * OWN `kind:'asset'` collection — hydrated session → playground config,
  * the exact same precedence {@link resolveCmsInitialCollections} gives every
  * other CMS collection — falling back to the engine's `assetCollection` fixture
  * only when nothing resolves (mirroring `CmsProvider`'s own fallback). A mount's
@@ -188,8 +187,6 @@ export declare function assetsView(config?: AssetsViewConfig): AppViewModule;
  * admin/config concern, so it appears/hides with a project's settings surface).
  */
 export declare function usersView(config?: BuiltinViewConfig): AppViewModule;
-/** The extensions marketplace view. */
-export declare function extensionsView(config?: BuiltinViewConfig): AppViewModule;
 /** The project settings view. */
 export declare function settingsView(config?: BuiltinViewConfig): AppViewModule;
 /** The legacy `builder` redirect — a hidden, routable view (so `/builder?page=` still lands). */
@@ -274,8 +271,6 @@ export declare const nav: {
     readonly redirects: (config?: RedirectsViewConfig) => SidebarViewNode;
     /** Project settings. */
     readonly settings: (config?: BuiltinViewConfig) => SidebarViewNode;
-    /** The extensions marketplace. */
-    readonly extensions: (config?: BuiltinViewConfig) => SidebarViewNode;
     /** The admin users roster (EC-240). */
     readonly users: (config?: BuiltinViewConfig) => SidebarViewNode;
     /** A fully custom view — pass your own `render` (and optional `parsePath`). */
@@ -302,11 +297,12 @@ export declare const nav: {
  * section rail reads `resolveDeploymentCollections()` directly, and now so does
  * the store's last rung, so the two can no longer disagree.
  */
-export declare function resolveCmsInitialCollections(cms: HydratedCms | null, kit: InstantiatedKit | undefined): CollectionDef[] | undefined;
+export declare function resolveCmsInitialCollections(cms: HydratedCms | null): CollectionDef[] | undefined;
 /**
  * The CMS documents source for a project mount — the document-side twin of
- * {@link resolveCmsInitialCollections}: a hydrated session wins (Convex), then a
- * kit's imported documents, then **nothing**.
+ * {@link resolveCmsInitialCollections}: a hydrated session wins (Convex), then
+ * **nothing**. (The middle rung, a starter kit's imported documents, went with
+ * the kits — EC-574; K rebuilds starter kits as seeds, EC-200/EC-475.)
  *
  * EC-479 — the third rung used to be the engine's own `sampleDocuments` fixture,
  * reconciled against the project's schema (EC-424). Reconciling it was already an
@@ -323,7 +319,7 @@ export declare function resolveCmsInitialCollections(cms: HydratedCms | null, ki
  * adapter seeds is `persistence/seed.ts`'s business — EC-475 (project-defined seed
  * content) owns it.
  */
-export declare function resolveCmsInitialDocuments(cms: HydratedCms | null, kit: InstantiatedKit | undefined): CmsDocument[] | undefined;
+export declare function resolveCmsInitialDocuments(cms: HydratedCms | null): CmsDocument[] | undefined;
 /**
  * The CMS locale config for a project mount (EC-357 finding #3). Locales are
  * structure and structure is code: when the active `elytra.config.ts` project
@@ -334,13 +330,17 @@ export declare function resolveCmsInitialDocuments(cms: HydratedCms | null, kit:
  * showed `EN·/DE` against a `locales: ['de']` config.
  *
  * EC-479/EC-483 — the ladder is now TOTAL, and every rung is the project's own:
- * config-declared locales, then (hydrated) its persisted settings, then a kit's,
- * then its settings regardless. A `Project` only ever exists for a config-declared
- * project (`studio-context.tsx`: `configProjects()`), so `project.settings` is
- * config-derived too — which is what lets the CMS session require a locale instead
- * of borrowing the engine's `en/de` fixture. The default locale is the literal
- * storage key for every localized value, so a guessed one is a data migration.
- * `configLocales` is a parameter purely so the ladder is unit-testable (same seam
- * pattern as {@link resolveCmsInitialCollections}).
+ * config-declared locales, then its settings (a starter kit's locales used to sit
+ * between the two; the kits went in EC-574). A `Project` only ever exists for a
+ * config-declared project (`studio-context.tsx`: `configProjects()`), so
+ * `project.settings` is config-derived too — which is what lets the CMS session
+ * require a locale instead of borrowing the engine's `en/de` fixture. The default
+ * locale is the literal storage key for every localized value, so a guessed one is
+ * a data migration. Both rungs are config-derived and pass the workspace gate
+ * (`default-locale-not-in-locales` is an error there), so the value is valid by
+ * construction and no reader repairs it. `configLocales` is a parameter purely so
+ * the ladder is unit-testable (same seam pattern as
+ * {@link resolveCmsInitialCollections}); `cms` is accepted for signature parity
+ * with its twins but no longer selects a rung.
  */
-export declare function resolveCmsInitialLocaleConfig(cms: HydratedCms | null, kit: InstantiatedKit | undefined, project: Project, configLocales?: LocaleConfig | undefined): LocaleConfig;
+export declare function resolveCmsInitialLocaleConfig(_cms: HydratedCms | null, project: Project, configLocales?: LocaleConfig | undefined): LocaleConfig;

package/dist/components/app-views/default-modules.js

@@ -1,11 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect } from 'react';
-import { Blocks, Database, FileCog, Image, LayoutGrid, Puzzle, Settings as SettingsIcon, Signpost, Users, } from 'lucide-react';
+import { Blocks, Database, FileCog, Image, LayoutGrid, Settings as SettingsIcon, Signpost, Users, } from 'lucide-react';
 import { assetCollection, extendCollectionDef, isSingleton, resolveSingletonDocument, } from '@elytracms/core/cms-core';
 import { NavigateOnce, STUDIO_PROJECT_ROUTE, studioPath } from '@elytracms/studio/router';
 import { Text } from '@elytracms/studio/ui';
 import { localizedLabel, translate } from '@elytracms/studio/lib/i18n';
-import { getInstantiatedKit } from '@elytracms/studio/lib/starters/kit-session';
 import { resolveDeploymentCollections, resolveDeploymentLocaleConfig } from '@elytracms/studio/lib/workspace';
 import { cmsDeepLink, componentsDeepLink, usersDeepLink, redirectsDeepLink, assetsDeepLink, groupNode, separatorNode, viewNode, } from './module.js';
 import { SectionSurface } from '../section-surface.js';
@@ -15,7 +14,6 @@ import { AssetsModule } from '../assets/assets-module.js';
 import { UsersModule } from '../users/users-module.js';
 import { RedirectsModule } from '../redirects/redirects-module.js';
 import { redirectsCollectionDef } from '../redirects/redirects-schema.js';
-import { ExtensionsView } from '../extensions/extensions-view.js';
 import { RegistryBrowser } from '../components/registry-browser.js';
 import { ComponentsIndex } from '../components/components-index.js';
 import { ComponentDetail } from '../components/component-detail.js';
@@ -210,7 +208,7 @@ export function redirectsView(config = {}) {
 }
 /**
  * Resolve the assets rail's EFFECTIVE schema (EC-319/EC-311): the deployment's
- * OWN `kind:'asset'` collection — hydrated session → kit → playground config,
+ * OWN `kind:'asset'` collection — hydrated session → playground config,
  * the exact same precedence {@link resolveCmsInitialCollections} gives every
  * other CMS collection — falling back to the engine's `assetCollection` fixture
  * only when nothing resolves (mirroring `CmsProvider`'s own fallback). A mount's
@@ -243,8 +241,7 @@ export function assetsView(config = {}) {
         availabilitySection: 'assets',
         parsePath: assetsDeepLink,
         render: (ctx) => (_jsx(SectionSurface, { project: ctx.project, section: "assets", forcedState: ctx.search.state, children: ctx.deepLink.assetId === null && ctx.search.asset ? (_jsx(NavigateOnce, { to: STUDIO_PROJECT_ROUTE, params: { projectId: ctx.projectId, _splat: studioPath.asset(ctx.search.asset) }, replace: true })) : (_jsx(CmsSessionGate, { children: (cms) => {
-                    const kit = getInstantiatedKit(ctx.projectId);
-                    const schema = resolveAssetsSchema(resolveCmsInitialCollections(cms, kit), config);
+                    const schema = resolveAssetsSchema(resolveCmsInitialCollections(cms), config);
                     return (_jsx(AssetsModule, { projectId: ctx.projectId, assetId: ctx.deepLink.assetId ?? null, schema: schema }));
                 } })) })),
     };
@@ -273,21 +270,6 @@ export function usersView(config = {}) {
         render: (ctx) => ctx.search.state && ctx.search.state !== 'working' ? (_jsx(SectionStateView, { state: ctx.search.state, title: translate('nav.users.label') })) : (_jsx(UsersModule, { projectId: ctx.projectId, userId: ctx.deepLink.userId ?? null })),
     };
 }
-/** The extensions marketplace view. */
-export function extensionsView(config = {}) {
-    return {
-        id: 'extensions',
-        get label() {
-            return config.label ?? translate('nav.extensions.label');
-        },
-        get description() {
-            return translate('nav.extensions.description');
-        },
-        icon: config.icon ?? Puzzle,
-        availabilitySection: 'extensions',
-        render: (ctx) => ctx.search.state && ctx.search.state !== 'working' ? (_jsx(SectionStateView, { state: ctx.search.state, title: translate('nav.extensions.label') })) : (_jsx(ExtensionsView, {})),
-    };
-}
 /** The project settings view. */
 export function settingsView(config = {}) {
     return {
@@ -355,7 +337,6 @@ export const DEFAULT_VIEWS = [
     cmsView(),
     redirectsView(),
     assetsView(),
-    extensionsView(),
     usersView(),
     settingsView(),
     builderView(),
@@ -505,8 +486,6 @@ export const nav = {
     redirects: (config = {}) => viewNode(withNavPermission(redirectsView(config), config)),
     /** Project settings. */
     settings: (config = {}) => viewNode(withNavPermission(settingsView(config), config)),
-    /** The extensions marketplace. */
-    extensions: (config = {}) => viewNode(withNavPermission(extensionsView(config), config)),
     /** The admin users roster (EC-240). */
     users: (config = {}) => viewNode(withNavPermission(usersView(config), config)),
     /** A fully custom view — pass your own `render` (and optional `parsePath`). */
@@ -545,13 +524,14 @@ function ComponentsScreen({ projectId, componentId, state, }) {
  * section rail reads `resolveDeploymentCollections()` directly, and now so does
  * the store's last rung, so the two can no longer disagree.
  */
-export function resolveCmsInitialCollections(cms, kit) {
-    return cms?.collections ?? kit?.collections ?? resolveDeploymentCollections();
+export function resolveCmsInitialCollections(cms) {
+    return cms?.collections ?? resolveDeploymentCollections();
 }
 /**
  * The CMS documents source for a project mount — the document-side twin of
- * {@link resolveCmsInitialCollections}: a hydrated session wins (Convex), then a
- * kit's imported documents, then **nothing**.
+ * {@link resolveCmsInitialCollections}: a hydrated session wins (Convex), then
+ * **nothing**. (The middle rung, a starter kit's imported documents, went with
+ * the kits — EC-574; K rebuilds starter kits as seeds, EC-200/EC-475.)
  *
  * EC-479 — the third rung used to be the engine's own `sampleDocuments` fixture,
  * reconciled against the project's schema (EC-424). Reconciling it was already an
@@ -568,8 +548,8 @@ export function resolveCmsInitialCollections(cms, kit) {
  * adapter seeds is `persistence/seed.ts`'s business — EC-475 (project-defined seed
  * content) owns it.
  */
-export function resolveCmsInitialDocuments(cms, kit) {
-    return cms?.documents ?? kit?.documents;
+export function resolveCmsInitialDocuments(cms) {
+    return cms?.documents;
 }
 /**
  * The CMS locale config for a project mount (EC-357 finding #3). Locales are
@@ -581,25 +561,26 @@ export function resolveCmsInitialDocuments(cms, kit) {
  * showed `EN·/DE` against a `locales: ['de']` config.
  *
  * EC-479/EC-483 — the ladder is now TOTAL, and every rung is the project's own:
- * config-declared locales, then (hydrated) its persisted settings, then a kit's,
- * then its settings regardless. A `Project` only ever exists for a config-declared
- * project (`studio-context.tsx`: `configProjects()`), so `project.settings` is
- * config-derived too — which is what lets the CMS session require a locale instead
- * of borrowing the engine's `en/de` fixture. The default locale is the literal
- * storage key for every localized value, so a guessed one is a data migration.
- * `configLocales` is a parameter purely so the ladder is unit-testable (same seam
- * pattern as {@link resolveCmsInitialCollections}).
+ * config-declared locales, then its settings (a starter kit's locales used to sit
+ * between the two; the kits went in EC-574). A `Project` only ever exists for a
+ * config-declared project (`studio-context.tsx`: `configProjects()`), so
+ * `project.settings` is config-derived too — which is what lets the CMS session
+ * require a locale instead of borrowing the engine's `en/de` fixture. The default
+ * locale is the literal storage key for every localized value, so a guessed one is
+ * a data migration. Both rungs are config-derived and pass the workspace gate
+ * (`default-locale-not-in-locales` is an error there), so the value is valid by
+ * construction and no reader repairs it. `configLocales` is a parameter purely so
+ * the ladder is unit-testable (same seam pattern as
+ * {@link resolveCmsInitialCollections}); `cms` is accepted for signature parity
+ * with its twins but no longer selects a rung.
  */
-export function resolveCmsInitialLocaleConfig(cms, kit, project, configLocales = resolveDeploymentLocaleConfig()) {
-    const projectSettings = {
+export function resolveCmsInitialLocaleConfig(_cms, project, configLocales = resolveDeploymentLocaleConfig()) {
+    if (configLocales)
+        return configLocales;
+    return {
         default: project.settings.defaultLocale,
         locales: [...project.settings.locales],
     };
-    if (configLocales)
-        return configLocales;
-    if (cms)
-        return projectSettings;
-    return kit?.localeConfig ?? projectSettings;
 }
 /**
  * CMS section: hydrates the persisted (or kit-seeded) collections + documents, then
@@ -614,10 +595,8 @@ function CmsScreen({ project, collectionId, documentId, state, field, focusColle
     if (state && state !== 'working') {
         return _jsx(SectionStateView, { state: state, title: translate('nav.cms.label') });
     }
-    // A project created from a starter kit (EC-119) opens the CMS on the kit's schemas + content.
-    const kit = getInstantiatedKit(projectId);
     return (_jsx(CmsSessionGate, { children: (cms) => {
-            return (_jsx(CmsProvider, { projectId: projectId, initialCollections: resolveCmsInitialCollections(cms, kit), initialDocuments: resolveCmsInitialDocuments(cms, kit), initialPublishedKeys: cms?.publishedKeys, initialTimestamps: cms?.timestamps, initialPublishTimestamps: cms?.publishTimestamps, initialChangedKeys: cms?.changedKeys, initialLocaleConfig: resolveCmsInitialLocaleConfig(cms, kit, project), 
+            return (_jsx(CmsProvider, { projectId: projectId, initialCollections: resolveCmsInitialCollections(cms), initialDocuments: resolveCmsInitialDocuments(cms), initialPublishedKeys: cms?.publishedKeys, initialTimestamps: cms?.timestamps, initialPublishTimestamps: cms?.publishTimestamps, initialChangedKeys: cms?.changedKeys, initialLocaleConfig: resolveCmsInitialLocaleConfig(cms, project), 
                 // EC-461: a hydrated mount (cms non-null — both modes now) seeds the
                 // CURRENT persisted state, so staged docs are superseded by it; only
                 // a static kit/fixture seed lets staged entries win.