@kernhq/module-quire 0.13.1 → 0.15.0

package/src/client/index.ts

@@ -27,8 +27,17 @@ export {
   type Comment,
   type CommentAnchor,
   type CommentThread,
+  type ExportFormat,
+  type ExportJob,
+  type ExportJobDetail,
+  type ExportScope,
   type Favorite,
   type FavoriteEntry,
+  type ImportJob,
+  type ImportJobSummary,
+  type ImportOutcome,
+  type ImportReportEntry,
+  type ImportSource,
   type Label,
   type LabelColour,
   MODULE_ID,
@@ -49,6 +58,27 @@ export {
   type RecentView,
   type Space,
   type SpaceVisibility,
+  TEMPLATE_BUILT_IN_VARIABLES,
+  TEMPLATE_STARTER_KEYS,
+  type Template,
+  /**
+   * A picker row: a shipped starter, or a template somebody saved.
+   *
+   * Exported because a screen outside this package will want to draw one — the "New page" picker
+   * lives here, but a dashboard widget offering "start a meeting note" is the obvious next thing,
+   * and it should read the shape from here rather than restate it.
+   */
+  type TemplateChoice,
+  type TemplateKind,
+  type TemplateResult,
+  type TemplateSpaceBody,
+  type TemplateSpaceNode,
+  type TemplateStarterKey,
+  type TemplateSummary,
+  type TemplateVariable,
+  type TemplateVariableType,
+  type TransferCounts,
+  type TransferState,
   type VersionKind,
   type Watcher,
   type WatchState,
@@ -141,3 +171,24 @@ export {
   publicSiteBasePath,
   publicSiteUrl,
 } from './public-url.js'
+/**
+ * The vocabulary of a transfer, as labels rather than as enum members.
+ *
+ * Exported for the same reason `descriptorFor` and `viewIcon` are: a state, a scope, a format and a
+ * source have exactly one right name each in each language, and anything that ends up drawing one —
+ * a widget, a notification renderer, a screen written later — should read it from here rather than
+ * re-deriving a `switch` that has to be kept in step with the contract's enums.
+ */
+export {
+  EXPORT_FORMATS,
+  formatDescription,
+  formatLabel,
+  IMPORT_SOURCES,
+  isRunning,
+  progressRatio,
+  scopeLabel,
+  sourceDescription,
+  sourceLabel,
+  stateIcon,
+  stateLabel,
+} from './transfers.js'

package/src/client/mock.ts

@@ -5,7 +5,13 @@ import type {
   Database,
   DatabaseRef,
   Row as DatabaseRow,
+  ExportFormat,
+  ExportJob,
+  ExportScope,
   FavoriteEntry,
+  ImportJob,
+  ImportReportEntry,
+  ImportSource,
   Label,
   LabelColour,
   Page,
@@ -18,6 +24,12 @@ import type {
   RecentEntry,
   RowRef,
   Space,
+  Template,
+  TemplateChoice,
+  TemplateKind,
+  TemplateResult,
+  TemplateVariable,
+  TransferCounts,
   View,
   ViewConfig,
   ViewKind,
@@ -918,6 +930,302 @@ export function createMockQuireApi() {
     return String(left).localeCompare(String(right))
   }
 
+  // ----------------------------------------------------------------------------------------------
+  // Getting work in and out
+  // ----------------------------------------------------------------------------------------------
+
+  /**
+   * A transfer is a job, so the mock has to behave like one rather than answer instantly.
+   *
+   * Every screen here is a progress bar, a spinner and a report that arrives afterwards, and a mock
+   * that returned `done` from `start` would leave all three unreachable — the demo and the
+   * end-to-end sweep would only ever see the finished state. So a started job carries a real
+   * `createdAt` and its state is **computed from how long ago that was**: queued for the first
+   * second, running while it counts, then done. No timers, so nothing keeps running after the tab
+   * that made it has gone.
+   *
+   * The seeded rows cover the three states somebody has to be able to look at without waiting: a
+   * finished export with a file, a failed one with a reason worth reading, and a finished import
+   * whose report has all three outcomes in it.
+   */
+  const EXPORT_STEP_MS = 320
+  const EXPORT_START_MS = 800
+  const IMPORT_READ_MS = 3200
+
+  /**
+   * A valid, empty zip — the 22-byte end-of-central-directory record and nothing else.
+   *
+   * There is no object storage behind `dev:mock`, so a download has to be something the browser can
+   * actually save; a `data:` URL is the only address that works without one. Empty rather than
+   * fabricated: a demo zip full of invented pages is a file somebody opens expecting their handbook.
+   */
+  const EMPTY_ZIP = 'data:application/zip;base64,UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA=='
+
+  const countsOf = (report: ImportReportEntry[]): TransferCounts => ({
+    total: report.length,
+    done: report.filter((r) => r.outcome === 'imported').length,
+    skipped: report.filter((r) => r.outcome === 'skipped').length,
+    failed: report.filter((r) => r.outcome === 'failed').length,
+  })
+
+  const exportJobs: ExportJob[] = [
+    {
+      id: uid(701),
+      workspaceId: '' as ExportJob['workspaceId'],
+      requestedBy: ME as ExportJob['requestedBy'],
+      scope: 'space',
+      targetId: uid(1),
+      format: 'markdown',
+      state: 'done',
+      fileId: uid(781),
+      error: null,
+      counts: { total: 8, done: 7, skipped: 1, failed: 0 },
+      createdAt: iso(72e5),
+      finishedAt: iso(71e5),
+    },
+    {
+      id: uid(702),
+      workspaceId: '' as ExportJob['workspaceId'],
+      requestedBy: ME as ExportJob['requestedBy'],
+      scope: 'subtree',
+      targetId: uid(102),
+      format: 'pdf',
+      state: 'failed',
+      fileId: null,
+      // The failure worth seeding is the one an operator can act on, written the way the service
+      // writes it: the PDF renderer is a separate container, and a stack with it switched off is by
+      // far the most common reason a PDF export dies.
+      error: 'The PDF service did not answer at http://gotenberg:3000 (connect ECONNREFUSED)',
+      counts: { total: 3, done: 3, skipped: 0, failed: 0 },
+      createdAt: iso(864e5),
+      finishedAt: iso(8636e4),
+    },
+  ]
+
+  /** One report with all three outcomes in it, because that is the whole point of the screen. */
+  const seededImportReport: ImportReportEntry[] = [
+    { path: 'Company Handbook 8f2c41d0.md', outcome: 'imported', pageId: uid(101), reason: null },
+    {
+      path: 'Company Handbook 8f2c41d0/Getting started 5b91aa02.md',
+      outcome: 'imported',
+      pageId: uid(103),
+      reason: null,
+    },
+    {
+      path: 'Company Handbook 8f2c41d0/Tasks 71cc9e10.csv',
+      outcome: 'imported',
+      pageId: uid(110),
+      // The one `imported` row that carries a reason, exactly as the server writes it: a CSV becomes
+      // a database, and the column types it guessed are the thing somebody has to check.
+      reason:
+        'the first column, Name, became each row’s title; Status: read as a select with 3 choices, from 4 of 4 values; Due: read as a date; Done: read as a checkbox',
+    },
+    {
+      path: 'Company Handbook 8f2c41d0/Tasks 71cc9e10_all.csv',
+      outcome: 'skipped',
+      pageId: null,
+      reason: 'a second view of the same database; its rows came from “Tasks 71cc9e10.csv”',
+    },
+    {
+      path: 'Company Handbook 8f2c41d0/diagram.png',
+      outcome: 'skipped',
+      pageId: null,
+      reason: 'a picture, which an import cannot yet attach to a page',
+    },
+    {
+      path: '__MACOSX/._Company Handbook 8f2c41d0.md',
+      outcome: 'skipped',
+      pageId: null,
+      reason: 'a file the operating system added to the archive',
+    },
+    {
+      path: 'Company Handbook 8f2c41d0/Expenses 04ab7731.md',
+      outcome: 'failed',
+      pageId: null,
+      reason: 'its checksum does not match, so the file is damaged',
+    },
+    {
+      path: 'Archive/Old wiki 22b0cc71.md',
+      outcome: 'failed',
+      pageId: null,
+      reason:
+        'nothing in the archive is at this path, so the link to it in “Company Handbook” is now plain text',
+    },
+  ]
+
+  const importJobs: ImportJob[] = [
+    {
+      id: uid(711),
+      workspaceId: '' as ImportJob['workspaceId'],
+      requestedBy: ME as ImportJob['requestedBy'],
+      source: 'notion',
+      targetId: uid(1),
+      sourceFileId: uid(791),
+      state: 'done',
+      error: null,
+      counts: countsOf(seededImportReport),
+      report: seededImportReport,
+      createdAt: iso(1728e5),
+      finishedAt: iso(17274e4),
+    },
+  ]
+
+  /** Move a queued export along by however long it has been sitting there. */
+  function advanceExport(row: ExportJob) {
+    if (row.state === 'done' || row.state === 'failed') return
+    const elapsed = Date.now() - new Date(row.createdAt).getTime()
+    if (elapsed < EXPORT_START_MS) return
+    const total = row.counts.total || 12
+    const seen = Math.min(total, Math.floor((elapsed - EXPORT_START_MS) / EXPORT_STEP_MS))
+    // One page withheld, so the "some pages were left out" sentence is reachable in the demo.
+    const skipped = Math.min(total > 4 ? 1 : 0, seen)
+    row.counts = { total, done: seen - skipped, skipped, failed: 0 }
+    row.state = seen >= total ? 'done' : 'running'
+    if (row.state === 'done') {
+      row.fileId = row.fileId ?? nextId()
+      row.finishedAt = new Date().toISOString()
+    }
+  }
+
+  /**
+   * Move a queued import along, and — when it lands — actually write the pages.
+   *
+   * The pages matter: an import whose report says three pages arrived and whose sidebar is unchanged
+   * is a demo of the wrong thing, and "Open the space" would lead somewhere that has not moved.
+   */
+  function advanceImport(row: ImportJob) {
+    if (row.state === 'done' || row.state === 'failed') return
+    const elapsed = Date.now() - new Date(row.createdAt).getTime()
+    if (elapsed < EXPORT_START_MS) return
+    if (elapsed < IMPORT_READ_MS) {
+      row.state = 'running'
+      return
+    }
+    const made = ['Company Handbook', 'Getting started', 'How we work'].map((title, at) => {
+      const created = page(++seq, row.targetId, title, `z${at}`, null, {})
+      created.id = uid(seq)
+      created.createdAt = new Date().toISOString()
+      created.updatedAt = created.createdAt
+      pages.push(created)
+      return created.id
+    })
+    row.report = [
+      { path: 'Company Handbook 8f2c41d0.md', outcome: 'imported', pageId: made[0] ?? null, reason: null },
+      {
+        path: 'Company Handbook 8f2c41d0/Getting started 5b91aa02.md',
+        outcome: 'imported',
+        pageId: made[1] ?? null,
+        reason: null,
+      },
+      {
+        path: 'Company Handbook 8f2c41d0/How we work 90ff1a44.md',
+        outcome: 'imported',
+        pageId: made[2] ?? null,
+        reason: null,
+      },
+      {
+        path: 'Company Handbook 8f2c41d0/logo.png',
+        outcome: 'skipped',
+        pageId: null,
+        reason: 'a picture, which an import cannot yet attach to a page',
+      },
+      {
+        path: 'Company Handbook 8f2c41d0/Notes 04ab7731.md',
+        outcome: 'failed',
+        pageId: null,
+        reason: 'its checksum does not match, so the file is damaged',
+      },
+    ]
+    row.counts = countsOf(row.report)
+    row.state = 'done'
+    row.finishedAt = new Date().toISOString()
+  }
+
+  /**
+   * The five starters, **in English only**.
+   *
+   * The real ones are constants on the server with a five-locale table beside them, resolved against
+   * the reader's own locale — `server/services/templates.ts` explains why they cannot live in this
+   * package's message bundle. This mock has no server and no principal, so it carries the English
+   * names and nothing else: it is the demo interface, and a demo of the picker is a demo of the
+   * shape rather than of the translation. Anything that needs to see a starter in Persian needs a
+   * server.
+   */
+  const STARTER_NAMES: Array<[string, string, string, string]> = [
+    ['meeting-notes', 'users', 'Meeting notes', 'Who was there, what was decided, and who does what next.'],
+    [
+      'decision-record',
+      'flag',
+      'Decision record',
+      'One decision, why it was taken, and what it commits you to.',
+    ],
+    [
+      'requirements',
+      'target',
+      'Requirements',
+      'What a piece of work has to do, and what it deliberately does not.',
+    ],
+    [
+      'retrospective',
+      'refresh-cw',
+      'Retrospective',
+      'What went well, what got in the way, and what to change.',
+    ],
+    ['how-to', 'wrench', 'How-to', 'A task somebody can follow from start to finish.'],
+  ]
+
+  /**
+   * One template somebody in this workspace already saved, so the picker is not five shipped entries
+   * and nothing else — the interesting half of the feature is the one a colleague made.
+   */
+  const templateRows: Template[] = [
+    {
+      id: uid(700),
+      workspaceId: '' as Template['workspaceId'],
+      spaceId: uid(1),
+      kind: 'page',
+      key: null,
+      builtIn: false,
+      name: 'Weekly review',
+      description: 'What moved this week, and what is stuck.',
+      icon: 'calendar-days',
+      doc: {
+        type: 'doc',
+        content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Week {{week}} · {{author}}' }] }],
+      },
+      variables: [
+        {
+          name: 'week',
+          label: 'Which week',
+          type: 'text',
+          options: [],
+          default: null,
+          required: true,
+        },
+      ],
+      createdBy: COLLEAGUE as Template['createdBy'],
+      createdAt: iso(9e6),
+      updatedAt: iso(9e6),
+    },
+  ]
+
+  const templateChoice = (row: Template): TemplateChoice => ({
+    id: row.id,
+    key: row.key,
+    builtIn: row.builtIn,
+    kind: row.kind,
+    spaceId: row.spaceId,
+    name: row.name,
+    description: row.description,
+    icon: row.icon,
+    variables: row.variables,
+    updatedAt: row.updatedAt,
+  })
+
+  /** The same single-pass, text-only substitution the server does — see `services/templates.ts`. */
+  const fill = (text: string, values: Record<string, string>) =>
+    text.replace(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/g, (whole, name: string) => values[name] ?? whole)
+
   return {
     spaces: {
       list: async ({ includeArchived = false }: { includeArchived?: boolean } = {}) =>
@@ -1380,6 +1688,290 @@ export function createMockQuireApi() {
       },
     },
 
+    /**
+     * Taking work out.
+     *
+     * `list` and `get` advance every job before answering, which is what makes the progress bar move
+     * in `dev:mock` — there is no worker here, so the passage of time is the worker. `docx` is
+     * refused exactly as the server refuses it, with the same shape of message: a mock that quietly
+     * accepted it would make the one format the product does not have look like the one it does.
+     */
+    exports: {
+      start: async (input: { scope: ExportScope; targetId: string; format: ExportFormat }) => {
+        if (input.format === 'docx')
+          throw Object.assign(
+            new Error(
+              'Word export is not available yet. Export as HTML or PDF, both of which Word opens, ' +
+                'or as Markdown to move the pages somewhere else.',
+            ),
+            { code: 'BAD_REQUEST' },
+          )
+        if (input.scope === 'space') {
+          if (!spaces.some((s) => s.id === input.targetId)) throw notFound('Space')
+        } else found(input.targetId)
+        const row: ExportJob = {
+          id: nextId(),
+          workspaceId: '' as ExportJob['workspaceId'],
+          requestedBy: ME as ExportJob['requestedBy'],
+          scope: input.scope,
+          targetId: input.targetId,
+          format: input.format,
+          state: 'queued',
+          fileId: null,
+          error: null,
+          counts: { total: 0, done: 0, skipped: 0, failed: 0 },
+          createdAt: new Date().toISOString(),
+          finishedAt: null,
+        }
+        exportJobs.unshift(row)
+        return { ...row, downloadUrl: null }
+      },
+
+      get: async ({ jobId }: { jobId: string }) => {
+        const row = exportJobs.find((j) => j.id === jobId)
+        if (!row) throw notFound('Export')
+        advanceExport(row)
+        /*
+         * The link is minted here and not stored, exactly as the server does it — the download is a
+         * signed URL that expires, so a row carrying one would be a row carrying an address that
+         * stops working. A PDF export hands back the same empty zip: there is nothing to render.
+         */
+        return { ...row, downloadUrl: row.state === 'done' ? EMPTY_ZIP : null }
+      },
+
+      list: async ({ limit = 20 }: { limit?: number } = {}) => {
+        for (const row of exportJobs) advanceExport(row)
+        return exportJobs.slice(0, limit).map((row) => ({ ...row }))
+      },
+    },
+
+    /**
+     * Getting work in.
+     *
+     * `start` does not read the upload — there is no storage behind `dev:mock` and nothing to read —
+     * but it does keep the two checks that decide whether the job may exist at all: the space is
+     * real, and the archive is a file this mock knows about. The pages appear when the job lands,
+     * so the sidebar changes underneath the report rather than the report claiming pages nobody has.
+     */
+    imports: {
+      start: async (input: { spaceId: string; source: ImportSource; fileId: string }) => {
+        if (!spaces.some((s) => s.id === input.spaceId)) throw notFound('Space')
+        const row: ImportJob = {
+          id: nextId(),
+          workspaceId: '' as ImportJob['workspaceId'],
+          requestedBy: ME as ImportJob['requestedBy'],
+          source: input.source,
+          targetId: input.spaceId,
+          sourceFileId: input.fileId,
+          state: 'queued',
+          error: null,
+          counts: { total: 0, done: 0, skipped: 0, failed: 0 },
+          report: [],
+          createdAt: new Date().toISOString(),
+          finishedAt: null,
+        }
+        importJobs.unshift(row)
+        return { ...row }
+      },
+
+      get: async ({ jobId }: { jobId: string }) => {
+        const row = importJobs.find((j) => j.id === jobId)
+        if (!row) throw notFound('Import')
+        advanceImport(row)
+        return { ...row }
+      },
+
+      /** Without the reports, as the server answers it — a list of thousands-of-rows reports is not a list. */
+      list: async ({ limit = 20 }: { limit?: number } = {}) => {
+        for (const row of importJobs) advanceImport(row)
+        return importJobs.slice(0, limit).map(({ report: _report, ...summary }) => summary)
+      },
+    },
+
+    /**
+     * What somebody writes with.
+     *
+     * The starters and the rows come back as one list with the override rule applied, exactly as the
+     * server does it — a row carrying a starter's key stands in that starter's place rather than
+     * appearing beside it, which is the whole shape a picker has to draw.
+     *
+     * `instantiate` makes a real page in the tree. It cannot write a *body*: there is no collab
+     * service behind `dev:mock`, and a page's prose lives there rather than in this list. So the
+     * title is substituted and the page appears where it should, and the body is the one thing a
+     * demo of this feature cannot show.
+     */
+    templates: {
+      list: async ({
+        kind = 'page',
+        spaceId = null,
+      }: {
+        kind?: TemplateKind
+        spaceId?: string | null
+      } = {}) => {
+        const rows = templateRows.filter(
+          (row) => row.kind === kind && (row.spaceId === null || row.spaceId === spaceId),
+        )
+        const byKey = new Map(rows.filter((row) => row.key).map((row) => [row.key as string, row]))
+        const out: TemplateChoice[] = []
+        if (kind === 'page')
+          for (const [key, icon, name, description] of STARTER_NAMES) {
+            const override = byKey.get(key)
+            out.push(
+              override
+                ? templateChoice(override)
+                : {
+                    id: null,
+                    key,
+                    builtIn: true,
+                    kind: 'page',
+                    spaceId: null,
+                    name,
+                    description,
+                    icon,
+                    variables: [],
+                    updatedAt: null,
+                  },
+            )
+          }
+        for (const row of rows)
+          if (!row.key || !STARTER_NAMES.some(([key]) => key === row.key)) out.push(templateChoice(row))
+        return out
+      },
+
+      get: async ({ templateId }: { templateId: string }) => {
+        const row = templateRows.find((t) => t.id === templateId)
+        if (!row) throw notFound('Template')
+        return row
+      },
+
+      createFromPage: async (input: {
+        kind?: TemplateKind
+        sourceId: string
+        spaceId?: string | null
+        name: string
+        description?: string
+        icon?: string | null
+        variables?: TemplateVariable[]
+        key?: string | null
+      }) => {
+        if (input.key && templateRows.some((t) => t.key === input.key))
+          throw Object.assign(new Error('This workspace already has its own version of that template'), {
+            code: 'CONFLICT',
+          })
+        const source = input.kind === 'space' ? null : found(input.sourceId)
+        const row: Template = {
+          id: nextId(),
+          workspaceId: '' as Template['workspaceId'],
+          spaceId: input.kind === 'space' ? null : (input.spaceId ?? null),
+          kind: input.kind ?? 'page',
+          key: input.key ?? null,
+          builtIn: Boolean(input.key),
+          name: input.name,
+          description: input.description ?? '',
+          icon: input.icon ?? null,
+          // No collab service, so there is no body to read — the title stands in for the prose, which
+          // is enough for the picker and honest about what a mock can know.
+          doc:
+            input.kind === 'space'
+              ? { pages: [] }
+              : {
+                  type: 'doc',
+                  content: [{ type: 'paragraph', content: [{ type: 'text', text: source?.title ?? '' }] }],
+                },
+          variables: input.variables ?? [],
+          createdBy: ME as Template['createdBy'],
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        }
+        templateRows.push(row)
+        return row
+      },
+
+      update: async ({ templateId, ...patch }: { templateId: string } & Partial<Template>) => {
+        const row = templateRows.find((t) => t.id === templateId)
+        if (!row) throw notFound('Template')
+        Object.assign(row, patch, { updatedAt: new Date().toISOString() })
+        return row
+      },
+
+      remove: async ({ templateId }: { templateId: string }) => {
+        const at = templateRows.findIndex((t) => t.id === templateId)
+        if (at < 0) throw notFound('Template')
+        templateRows.splice(at, 1)
+        return { ok: true as const }
+      },
+
+      instantiate: async (input: {
+        templateId?: string | null
+        starterKey?: string | null
+        spaceId?: string | null
+        parentId?: string | null
+        afterId?: string | null
+        title?: string
+        key?: string | null
+        name?: string
+        values?: Record<string, string>
+      }): Promise<TemplateResult> => {
+        const row = input.templateId
+          ? templateRows.find((t) => t.id === input.templateId)
+          : templateRows.find((t) => t.key === input.starterKey)
+        const starter = STARTER_NAMES.find(([key]) => key === input.starterKey)
+        if (!row && !starter) throw notFound('Template')
+
+        const values: Record<string, string> = {
+          date: new Date().toLocaleDateString(),
+          time: new Date().toLocaleTimeString(),
+          author: 'You',
+          space: spaces.find((s) => s.id === input.spaceId)?.name ?? '',
+          ...(input.values ?? {}),
+        }
+        for (const variable of row?.variables ?? [])
+          if (variable.required && !values[variable.name])
+            throw Object.assign(new Error(`"${variable.label}" is needed before this can be made`), {
+              code: 'BAD_REQUEST',
+            })
+
+        if (row?.kind === 'space') {
+          if (!input.key || !input.name)
+            throw Object.assign(new Error('A space template needs a name and an address'), {
+              code: 'BAD_REQUEST',
+            })
+          const space: Space = {
+            id: nextId(),
+            workspaceId: '' as Space['workspaceId'],
+            key: input.key,
+            name: fill(input.name, values),
+            description: '',
+            icon: null,
+            visibility: 'open',
+            homepageId: null,
+            createdBy: ME as Space['createdBy'],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            archivedAt: null,
+          }
+          spaces.push(space)
+          return { spaceId: space.id, pageId: null, pageCount: 0 }
+        }
+
+        const spaceId = input.spaceId
+        if (!spaceId) throw Object.assign(new Error('A page template needs a space'), { code: 'BAD_REQUEST' })
+        const siblings = pages
+          .filter((p) => p.spaceId === spaceId && p.parentId === (input.parentId ?? null) && !p.deletedAt)
+          .sort((a, b) => (a._order < b._order ? -1 : 1))
+        const title = fill(input.title || row?.name || starter?.[2] || '', values)
+        const created = page(++seq, spaceId, title, `${siblings.at(-1)?._order ?? 'a'}m`, null, {
+          icon: row?.icon ?? starter?.[1] ?? null,
+        })
+        created.id = uid(seq)
+        created.parentId = input.parentId ?? null
+        created.createdAt = new Date().toISOString()
+        created.updatedAt = created.createdAt
+        pages.push(created)
+        return { spaceId, pageId: created.id, pageCount: 1 }
+      },
+    },
+
     publishing: {
       publish: async ({ pageId, label = null }: { pageId: string; label?: string | null }) => {
         const row = found(pageId)