@byline/cli 3.21.0 → 4.0.0

package/dist/templates/byline-examples/scripts/import-docs.ts

@@ -12,11 +12,6 @@
 // pnpm tsx byline/scripts/import-docs.ts ../../docs/**/*.md --verbose
 // pnpm tsx byline/scripts/import-docs.ts '../../docs/*.md' --dry-run --verbose
 // pnpm tsx byline/scripts/import-docs.ts ../../docs/**/*.md
-//
-// Run tests...
-//
-// pnpm vitest run --mode=node byline/scripts/lib/
-
 /**
  * Import markdown files into the `docs` collection.
  *
@@ -59,7 +54,7 @@ import { glob } from 'node:fs/promises'
 import { basename, dirname, join, resolve } from 'node:path'
 
 import { createSuperAdminContext } from '@byline/auth'
-import { type CollectionHandle, createBylineClient } from '@byline/client'
+import { type BylineClient, type CollectionHandle, createBylineClient } from '@byline/client'
 import { getCollectionDefinition, getServerConfig, slugify } from '@byline/core'
 
 import { type DocFrontmatter, parseDocFile } from './lib/frontmatter.js'
@@ -67,12 +62,16 @@ import { type MdastToLexicalWarning, mdastToLexical } from './lib/mdast-to-lexic
 import { parseBodyToMdast } from './lib/parse-markdown.js'
 import { type DocLinkRewriteWarning, rewriteDocLinks } from './lib/rewrite-doc-links.js'
 import { stripLeadingH1IfMatches } from './lib/strip-leading-h1.js'
+import type { CollectionFieldsByPath, DocsFields } from '../generated/collection-types.js'
 
 const DOCS_COLLECTION = 'docs'
 const MEDIA_COLLECTION = 'media'
 const DOCS_URL_PREFIX = '/docs'
 const DEFAULT_IMPORT_STATUS = 'published'
 
+type AppBylineClient = BylineClient<CollectionFieldsByPath>
+type DocsHandle = CollectionHandle<DocsFields>
+
 interface Flags {
   dryRun: boolean
   verbose: boolean
@@ -135,7 +134,7 @@ interface ResolvedFeatureImage {
 }
 
 async function resolveFeatureImage(
-  client: ReturnType<typeof createBylineClient>,
+  client: AppBylineClient,
   path: string
 ): Promise<ResolvedFeatureImage | null> {
   const mediaCollectionId = await client.resolveCollectionId(MEDIA_COLLECTION)
@@ -186,7 +185,7 @@ function derivePath(frontmatter: DocFrontmatter, locale: string): string {
  * workflow doesn't include the target or when already at/past it.
  */
 async function walkToStatus(
-  handle: CollectionHandle,
+  handle: DocsHandle,
   documentId: string,
   workflowStatuses: readonly { name: string }[],
   currentStatus: string,
@@ -230,8 +229,8 @@ function buildSourcePathMap(files: string[], defaultLocale: string): Map<string,
 
 async function processFile(
   filePath: string,
-  client: ReturnType<typeof createBylineClient>,
-  handle: CollectionHandle,
+  client: AppBylineClient,
+  handle: DocsHandle,
   flags: Flags,
   pathMap: Map<string, string>
 ): Promise<ProcessResult> {
@@ -340,7 +339,7 @@ function parentIndexFile(filePath: string): string {
  * processed in sorted order, so prefix order carries straight through.
  */
 async function placeTreeFromDirectories(
-  handle: CollectionHandle,
+  handle: DocsHandle,
   results: ProcessResult[]
 ): Promise<void> {
   const placeable = results.filter(
@@ -392,7 +391,7 @@ async function run(): Promise<void> {
 
   const config = getServerConfig()
   const requestContext = createSuperAdminContext({ id: 'import-docs-script' })
-  const client = createBylineClient({ config, requestContext })
+  const client = createBylineClient<CollectionFieldsByPath>({ config, requestContext })
   const handle = client.collection(DOCS_COLLECTION)
 
   // Pre-pass: map each source file to the path its imported doc will

package/dist/templates/byline-examples/scripts/lib/mdast-to-lexical.test.node.ts

@@ -24,312 +24,172 @@ describe('mdastToLexical', () => {
     expect(state.root.children[0]).toMatchObject({ type: 'paragraph', children: [] })
   })
 
-  test('paragraph with plain text', () => {
-    const { state } = convert('hello world')
-    expect(state.root.children[0]).toMatchObject({
+  test('maps plain paragraphs and every heading depth', () => {
+    const paragraph = convert('hello world').state.root.children[0]
+    expect(paragraph).toMatchObject({
       type: 'paragraph',
       children: [{ type: 'text', text: 'hello world', format: 0 }],
     })
+    const headings = convert('# h1\n\n## h2\n\n###### h6').state.root.children
+    expect(headings.map((node) => (node as { tag: string }).tag)).toEqual(['h1', 'h2', 'h6'])
   })
 
-  test('heading depth maps to tag h1-h6', () => {
-    const { state } = convert('# h1\n\n## h2\n\n###### h6')
-    expect(state.root.children).toHaveLength(3)
+  test('maps headings and composed inline formatting', () => {
+    const { state } = convert('# heading\n\n***both*** and `code`')
     expect(state.root.children[0]).toMatchObject({ type: 'heading', tag: 'h1' })
-    expect(state.root.children[1]).toMatchObject({ type: 'heading', tag: 'h2' })
-    expect(state.root.children[2]).toMatchObject({ type: 'heading', tag: 'h6' })
-  })
-
-  test('bold + italic compose into a single text node with bitmask format=3', () => {
-    const { state } = convert('***both***')
-    const paragraph = state.root.children[0] as unknown as {
+    const paragraph = state.root.children[1] as unknown as {
       children: Array<{ format: number; text: string }>
     }
-    expect(paragraph.children).toHaveLength(1)
-    expect(paragraph.children[0]).toMatchObject({ text: 'both', format: 1 | 2 })
-  })
-
-  test('inline code carries the IS_CODE bit', () => {
-    const { state } = convert('a `b` c')
-    const paragraph = state.root.children[0] as unknown as {
-      children: Array<{ format: number; text: string }>
-    }
-    // 'a ', code 'b', ' c'
-    expect(paragraph.children.map((c) => ({ text: c.text, format: c.format }))).toEqual([
-      { text: 'a ', format: 0 },
-      { text: 'b', format: 1 << 4 },
-      { text: ' c', format: 0 },
-    ])
+    expect(paragraph.children).toContainEqual(expect.objectContaining({ text: 'both', format: 3 }))
+    expect(paragraph.children).toContainEqual(
+      expect.objectContaining({ text: 'code', format: 1 << 4 })
+    )
   })
 
-  test('strikethrough (GFM) carries the strikethrough bit', () => {
+  test('preserves GFM strikethrough', () => {
     const { state } = convert('a ~~b~~ c')
     const paragraph = state.root.children[0] as unknown as {
       children: Array<{ format: number; text: string }>
     }
-    const struck = paragraph.children.find((c) => c.text === 'b')
-    expect(struck?.format).toBe(1 << 2)
+    expect(paragraph.children.find((child) => child.text === 'b')?.format).toBe(1 << 2)
   })
 
-  test('unordered list emits listType=bullet, tag=ul, listitems with peeled paragraph children', () => {
-    const { state } = convert('- one\n- two')
-    const list = state.root.children[0] as unknown as {
-      type: string
+  test('maps unordered, ordered, and nested lists', () => {
+    const unordered = convert('- a\n  - a1\n- b').state.root.children[0] as unknown as {
       listType: string
       tag: string
-      children: Array<{ type: string; children: Array<{ type: string; text: string }> }>
+      children: Array<{ children: Array<{ type: string }> }>
     }
-    expect(list).toMatchObject({ type: 'list', listType: 'bullet', tag: 'ul' })
-    expect(list.children).toHaveLength(2)
-    expect(list.children[0]).toMatchObject({
-      type: 'listitem',
-      children: [{ type: 'text', text: 'one' }],
-    })
-  })
+    expect(unordered).toMatchObject({ listType: 'bullet', tag: 'ul' })
+    expect(unordered.children[0].children.some((child) => child.type === 'list')).toBe(true)
 
-  test('ordered list propagates start and numbers values', () => {
-    const { state } = convert('3. a\n4. b')
-    const list = state.root.children[0] as unknown as {
+    const ordered = convert('3. a\n4. b').state.root.children[0] as unknown as {
       listType: string
       tag: string
       start: number
       children: Array<{ value: number }>
     }
-    expect(list).toMatchObject({ listType: 'number', tag: 'ol', start: 3 })
-    expect(list.children[0].value).toBe(3)
-    expect(list.children[1].value).toBe(4)
+    expect(ordered).toMatchObject({ listType: 'number', tag: 'ol', start: 3 })
+    expect(ordered.children.map((child) => child.value)).toEqual([3, 4])
   })
 
-  test('nested list lives inside the parent listitem', () => {
-    const { state } = convert('- a\n  - a1\n- b')
-    const list = state.root.children[0] as unknown as {
-      children: Array<{ children: Array<{ type: string }> }>
+  test('maps links and fenced code language aliases', () => {
+    const linkParagraph = convert('[label](https://example.com)').state.root
+      .children[0] as unknown as {
+      children: Array<{ attributes: { url: string; newTab: boolean } }>
     }
-    const firstItemChildren = list.children[0].children
-    expect(firstItemChildren.some((c) => c.type === 'list')).toBe(true)
-  })
-
-  test('link emits link node with custom attributes envelope', () => {
-    const { state } = convert('[label](https://example.com)')
-    const paragraph = state.root.children[0] as unknown as {
-      children: Array<{
-        type: string
-        attributes?: { linkType?: string; url?: string; newTab?: boolean }
-        children?: Array<{ text: string }>
-      }>
-    }
-    const link = paragraph.children[0]
-    expect(link.type).toBe('link')
-    expect(link.attributes).toMatchObject({
-      linkType: 'custom',
+    expect(linkParagraph.children[0].attributes).toMatchObject({
       url: 'https://example.com',
       newTab: true,
     })
-    expect(link.children?.[0]).toMatchObject({ text: 'label' })
-  })
 
-  test('fenced code with language stores `language` and emits code-highlight + linebreak children', () => {
-    const { state } = convert('```ts\nconst x = 1\nconst y = 2\n```')
-    const code = state.root.children[0] as unknown as {
-      type: string
+    const code = convert('```ts\nconst x = 1\n```').state.root.children[0] as unknown as {
       language: string
       children: Array<{ type: string; text?: string }>
     }
-    expect(code).toMatchObject({ type: 'code', language: 'typescript' })
+    expect(code.language).toBe('typescript')
     expect(code.children[0]).toMatchObject({ type: 'code-highlight', text: 'const x = 1' })
-    expect(code.children[1]).toMatchObject({ type: 'linebreak' })
-    expect(code.children[2]).toMatchObject({ type: 'code-highlight', text: 'const y = 2' })
-  })
-
-  test('thematic break emits horizontalrule', () => {
-    const { state } = convert('---')
-    expect(state.root.children[0]).toMatchObject({ type: 'horizontalrule' })
-  })
-
-  test('blockquote flattens single paragraph into inline children', () => {
-    const { state } = convert('> hello')
-    const quote = state.root.children[0] as unknown as {
-      type: string
-      children: Array<{ type: string; text?: string }>
-    }
-    expect(quote.type).toBe('quote')
-    expect(quote.children).toEqual([expect.objectContaining({ type: 'text', text: 'hello' })])
   })
 
-  test('image at block level is dropped with a warning', () => {
-    const { warnings, state } = convert('![alt](https://example.com/x.png)')
-    expect(warnings.some((w) => w.kind === 'dropped-image')).toBe(true)
-    // Paragraph survives as empty (image was its only child)
-    expect(state.root.children[0]).toMatchObject({ type: 'paragraph' })
+  test('maps blockquotes, rules, and image warnings', () => {
+    expect(convert('> hello').state.root.children[0]).toMatchObject({ type: 'quote' })
+    expect(convert('---').state.root.children[0]).toMatchObject({ type: 'horizontalrule' })
+    expect(convert('![alt](https://example.com/x.png)').warnings).toContainEqual(
+      expect.objectContaining({ kind: 'dropped-image' })
+    )
   })
 
-  test('GFM table maps to table/tablerow/tablecell with first-row headerState', () => {
-    const md = '| a | b |\n| - | - |\n| 1 | 2 |\n'
-    const { state, warnings } = convert(md)
-    expect(warnings).toEqual([])
-
-    const table = state.root.children[0] as unknown as {
-      type: string
+  test('maps GFM tables with header state and inline formatting', () => {
+    const table = convert('| col |\n| - |\n| **bold** |').state.root
+      .children[0] as unknown as {
       children: Array<{
-        type: string
         children: Array<{
-          type: string
           headerState: number
-          children: Array<{ type: string; children: Array<{ text: string }> }>
+          children: Array<{ children: Array<{ text: string; format: number }> }>
         }>
       }>
     }
-    expect(table.type).toBe('table')
-    expect(table.children).toHaveLength(2)
-
-    const [headerRow, bodyRow] = table.children
-    expect(headerRow.type).toBe('tablerow')
-    expect(bodyRow.type).toBe('tablerow')
-    expect(headerRow.children[0]).toMatchObject({ type: 'tablecell', headerState: 1 })
-    expect(headerRow.children[1]).toMatchObject({ type: 'tablecell', headerState: 1 })
-    expect(bodyRow.children[0]).toMatchObject({ type: 'tablecell', headerState: 0 })
-    expect(bodyRow.children[1]).toMatchObject({ type: 'tablecell', headerState: 0 })
-
-    // Inline cell content is wrapped in a paragraph.
-    const firstHeaderCell = headerRow.children[0]
-    expect(firstHeaderCell.children[0].type).toBe('paragraph')
-    expect(firstHeaderCell.children[0].children[0]).toMatchObject({ text: 'a' })
-    expect(bodyRow.children[1].children[0].children[0]).toMatchObject({ text: '2' })
+    expect(table.children[0].children[0].headerState).toBe(1)
+    expect(table.children[1].children[0].headerState).toBe(0)
+    expect(table.children[1].children[0].children[0].children[0]).toMatchObject({
+      text: 'bold',
+      format: 1,
+    })
   })
 
-  test('empty cell emits a paragraph with no children', () => {
-    const md = '| a | b |\n| - | - |\n|   | 2 |\n'
-    const { state } = convert(md)
-    const table = state.root.children[0] as unknown as {
+  test('gives empty table cells a structurally valid empty paragraph', () => {
+    const table = convert('| a | b |\n| - | - |\n|   | 2 |').state.root
+      .children[0] as unknown as {
       children: Array<{
         children: Array<{ children: Array<{ type: string; children: unknown[] }> }>
       }>
     }
-    const emptyCellParagraph = table.children[1].children[0].children[0]
-    expect(emptyCellParagraph).toMatchObject({ type: 'paragraph', children: [] })
-  })
-
-  test('inline formatting inside cells is preserved', () => {
-    const md = '| col |\n| - |\n| **bold** |\n'
-    const { state } = convert(md)
-    const table = state.root.children[0] as unknown as {
-      children: Array<{
-        children: Array<{
-          children: Array<{ children: Array<{ text: string; format: number }> }>
-        }>
-      }>
-    }
-    const bodyCellInline = table.children[1].children[0].children[0].children[0]
-    expect(bodyCellInline).toMatchObject({ text: 'bold', format: 1 })
+    expect(table.children[1].children[0].children[0]).toMatchObject({
+      type: 'paragraph',
+      children: [],
+    })
   })
 
-  test('code fence language is normalized to prism-known ids', () => {
+  test('normalizes common code fence aliases and preserves known names', () => {
     const cases: Array<[string, string]> = [
       ['ts', 'typescript'],
       ['js', 'javascript'],
       ['sh', 'bash'],
       ['yml', 'yaml'],
-      ['tsx', 'tsx'], // already prism-known, passes through
+      ['tsx', 'tsx'],
     ]
     for (const [input, expected] of cases) {
-      const { state } = convert(`\`\`\`${input}\nx\n\`\`\``)
-      const code = state.root.children[0] as unknown as { language: string }
+      const code = convert(`\`\`\`${input}\nx\n\`\`\``).state.root.children[0] as unknown as {
+        language: string
+      }
       expect(code.language).toBe(expected)
     }
   })
 
-  test('hard-wrapped paragraph collapses internal newlines to spaces', () => {
-    const md =
-      'In a world where AI produces content fast,\ninto dozens of languages,\nwhy does a CMS matter?'
-    const { state } = convert(md)
-    const paragraph = state.root.children[0] as unknown as {
+  test('collapses hard-wrapped paragraph newlines', () => {
+    const paragraph = convert('first line,\nsecond line.').state.root.children[0] as unknown as {
       children: Array<{ text: string }>
     }
-    // Single text node with newlines collapsed to single spaces — no
-    // <br> nodes and no embedded \n.
-    expect(paragraph.children).toHaveLength(1)
-    expect(paragraph.children[0].text).toBe(
-      'In a world where AI produces content fast, into dozens of languages, why does a CMS matter?'
-    )
+    expect(paragraph.children[0].text).toBe('first line, second line.')
   })
 
-  describe('admonitions', () => {
-    test('titled note becomes an admonition node with body paragraphs', () => {
-      const md = [':::note[Heads up]', 'First line.', '', 'Second line.', ':::'].join('\n')
-      const { state, warnings } = convert(md)
-      expect(warnings).toEqual([])
-      expect(state.root.children).toHaveLength(1)
-      const adm = state.root.children[0] as unknown as {
-        type: string
-        admonitionType: string
-        title: string
-        children: Array<{ type: string; children: Array<{ text: string }> }>
-      }
-      expect(adm).toMatchObject({ type: 'admonition', admonitionType: 'note', title: 'Heads up' })
-      expect(adm.children).toHaveLength(2)
-      expect(adm.children[0]).toMatchObject({ type: 'paragraph' })
-      expect(adm.children[0].children[0].text).toBe('First line.')
-      expect(adm.children[1].children[0].text).toBe('Second line.')
-    })
-
-    test('inline formatting + links survive inside an admonition body', () => {
-      const md = [
-        ':::warning[Careful]',
-        'This is **bold** and a [link](https://x.io).',
-        ':::',
-      ].join('\n')
-      const { state } = convert(md)
-      const adm = state.root.children[0] as unknown as {
-        admonitionType: string
-        children: Array<{ children: Array<{ type: string; text?: string; format?: number }> }>
-      }
-      expect(adm.admonitionType).toBe('warning')
-      const inline = adm.children[0].children
-      expect(inline).toContainEqual(expect.objectContaining({ text: 'bold', format: 1 }))
-      expect(inline).toContainEqual(expect.objectContaining({ type: 'link' }))
-    })
+  test('maps admonitions and ignores colon-bearing prose', () => {
+    const admonition = convert(':::warning[Careful]\nThis is **bold**.\n:::').state.root
+      .children[0] as unknown as {
+      admonitionType: string
+      title: string
+      children: Array<{ children: Array<{ text?: string; format?: number }> }>
+    }
+    expect(admonition).toMatchObject({ admonitionType: 'warning', title: 'Careful' })
+    expect(admonition.children[0].children).toContainEqual(
+      expect.objectContaining({ text: 'bold', format: 1 })
+    )
 
-    test('untitled admonition carries an empty title', () => {
-      const { state } = convert([':::tip', 'A quick tip.', ':::'].join('\n'))
-      const adm = state.root.children[0] as unknown as { admonitionType: string; title: string }
-      expect(adm).toMatchObject({ admonitionType: 'tip', title: '' })
-    })
+    const prose = convert('Run at 9:30 with a 1:2:3 ratio and note:foo.')
+    expect(prose.warnings).toEqual([])
+    expect(prose.state.root.children[0]).toMatchObject({ type: 'paragraph' })
+  })
 
-    test('an empty admonition body is seeded with one empty paragraph', () => {
-      const { state } = convert([':::danger[Stop]', ':::'].join('\n'))
-      const adm = state.root.children[0] as unknown as {
-        admonitionType: string
-        children: Array<{ type: string; children: unknown[] }>
-      }
-      expect(adm.admonitionType).toBe('danger')
-      expect(adm.children).toEqual([expect.objectContaining({ type: 'paragraph', children: [] })])
-    })
+  test('supports untitled, empty, and source-ordered admonitions', () => {
+    const untitled = convert(':::tip\nA quick tip.\n:::').state.root.children[0]
+    expect(untitled).toMatchObject({ admonitionType: 'tip', title: '' })
 
-    test('admonitions sit alongside ordinary blocks in source order', () => {
-      const md = ['# Title', '', ':::note[Note]', 'Body.', ':::', '', 'After.'].join('\n')
-      const { state } = convert(md)
-      expect(state.root.children.map((c) => (c as { type: string }).type)).toEqual([
-        'heading',
-        'admonition',
-        'paragraph',
-      ])
-    })
+    const empty = convert(':::danger[Stop]\n:::').state.root.children[0] as unknown as {
+      children: Array<{ type: string; children: unknown[] }>
+    }
+    expect(empty.children).toEqual([expect.objectContaining({ type: 'paragraph', children: [] })])
 
-    test('colon-bearing prose is never mistaken for a directive', () => {
-      // The line scanner only matches the four container fences, so inline
-      // colons (`9:30`, `1:2:3`, `note:foo`) pass through untouched.
-      const { state, warnings } = convert('Run at 9:30 with a 1:2:3 ratio and note:foo.')
-      expect(warnings).toEqual([])
-      const paragraph = state.root.children[0] as unknown as { children: Array<{ text: string }> }
-      expect(paragraph.children).toHaveLength(1)
-      expect(paragraph.children[0].text).toBe('Run at 9:30 with a 1:2:3 ratio and note:foo.')
-    })
+    const ordered = convert('# Title\n\n:::note[Note]\nBody.\n:::\n\nAfter.').state.root.children
+    expect(ordered.map((node) => (node as { type: string }).type)).toEqual([
+      'heading',
+      'admonition',
+      'paragraph',
+    ])
+  })
 
-    test('a `:::` fence inside a code block is treated as literal code', () => {
-      const md = ['```', ':::note[Not an admonition]', 'still code', ':::', '```'].join('\n')
-      const { state } = convert(md)
-      expect(state.root.children).toHaveLength(1)
-      expect(state.root.children[0]).toMatchObject({ type: 'code' })
-    })
+  test('keeps admonition-looking fences inside code blocks as code', () => {
+    const state = convert('```\n:::note[Not an admonition]\nstill code\n:::\n```').state
+    expect(state.root.children).toHaveLength(1)
+    expect(state.root.children[0]).toMatchObject({ type: 'code' })
   })
 })

package/dist/templates/byline-examples/scripts/lib/mdast-to-lexical.ts

@@ -11,7 +11,7 @@
  *
  * Pure, headless-editor-free conversion. The output JSON is shaped to
  * match what the runtime serializer in
- * `apps/webapp/src/ui/byline/components/richtext-lexical/serialize`
+ * `src/ui/byline/components/richtext-lexical/serialize`
  * expects to render (heading.tag, list.tag + list.listType, code
  * children of type 'code-highlight' interspersed with 'linebreak',
  * link.attributes, etc.).
@@ -47,7 +47,7 @@ import type {
 import type { AdmonitionDirective } from './parse-markdown.js'
 
 // Lexical inline format bits — kept in sync with
-// apps/webapp/src/ui/byline/components/richtext-lexical/serialize/richtext-node-formats.ts
+// src/ui/byline/components/richtext-lexical/serialize/richtext-node-formats.ts
 const IS_BOLD = 1
 const IS_ITALIC = 1 << 1
 const IS_STRIKETHROUGH = 1 << 2

package/dist/templates/byline-examples/scripts/lib/strip-leading-h1.test.node.ts

@@ -33,10 +33,6 @@ describe('stripLeadingH1IfMatches', () => {
   })
 
   test('match flattens inline formatting in the H1', () => {
-    // mdast-util-to-string drops backticks / emphasis markers from the
-    // H1's inline structure. Frontmatter titles are plain prose, so a
-    // body H1 of '# Client SDK (`@byline/client`)' compares equal to a
-    // frontmatter title of 'Client SDK (@byline/client)'.
     const root = parse('# Client SDK (`@byline/client`)\n\nbody')
     const out = stripLeadingH1IfMatches(root, 'Client SDK (@byline/client)')
     expect(out.children).toHaveLength(1)

package/dist/templates/byline-examples/scripts/re-anchor.ts

@@ -16,9 +16,9 @@
  * listed — that list is the outstanding-translation backlog. Re-run as
  * translation progresses; it is idempotent (each doc is its own transaction).
  *
- *   cd apps/webapp && pnpm tsx byline/scripts/re-anchor.ts --to fr
- *   cd apps/webapp && pnpm tsx byline/scripts/re-anchor.ts --to fr --collection pages
- *   cd apps/webapp && pnpm tsx byline/scripts/re-anchor.ts --to fr --dry-run
+ *   pnpm tsx byline/scripts/re-anchor.ts --to fr
+ *   pnpm tsx byline/scripts/re-anchor.ts --to fr --collection pages
+ *   pnpm tsx byline/scripts/re-anchor.ts --to fr --dry-run
  *
  * See docs/07-internationalization/index.md.
  */

package/dist/templates/byline-examples/scripts/regenerate-media.ts

@@ -59,11 +59,12 @@ import {
   getCollectionDefinition,
   getServerConfig,
   getWorkflowStatuses,
-  type StoredFileValue,
 } from '@byline/core'
 import { extractImageMeta, generateImageVariants, isBypassMimeType } from '@byline/core/image'
 import { uploadField as coreUploadField } from '@byline/core/services'
 
+import type { CollectionFieldsByPath, MediaFields } from '../generated/collection-types.js'
+
 const COLLECTION_PATH = 'media'
 const FIELD_NAME = 'image'
 
@@ -92,7 +93,7 @@ async function run(): Promise<void> {
   }
 
   const requestContext = createSuperAdminContext({ id: 'regenerate-media-script' })
-  const client = createBylineClient({ config, requestContext })
+  const client = createBylineClient<CollectionFieldsByPath>({ config, requestContext })
 
   const { id: collectionId, version: collectionVersion } =
     await client.resolveCollectionRecord(COLLECTION_PATH)
@@ -108,7 +109,7 @@ async function run(): Promise<void> {
     id: string
     path: string
     status: string
-    fields: Record<string, any>
+    fields: MediaFields
   }[] = []
   const pageSize = 100
   for (let page = 1; ; page++) {
@@ -123,7 +124,7 @@ async function run(): Promise<void> {
         id: d.id,
         path: d.path,
         status: d.status,
-        fields: d.fields as Record<string, any>,
+        fields: d.fields,
       })
     }
     if (result.docs.length < pageSize) break
@@ -154,7 +155,7 @@ async function run(): Promise<void> {
   let skipped = 0
 
   for (const doc of allDocs) {
-    const image = doc.fields[FIELD_NAME] as StoredFileValue | undefined | null
+    const image = doc.fields[FIELD_NAME]
     if (image == null || !image.storagePath) {
       console.log(`  - skip ${doc.id} (${doc.path}) — no image value`)
       skipped += 1

package/dist/templates/byline-examples/server.config.ts

@@ -28,8 +28,9 @@ import {
 import { migrate, postgresSearch } from '@byline/search-postgres'
 import { localStorageProvider } from '@byline/storage-local'
 
-import { getAdminBylineClient } from './client.server.js'
+import { getAdminBylineClient } from './clients.server.js'
 import { collections } from './collections/index.js'
+import { serverHooks } from './collections/server-hooks.js'
 import { i18n } from './i18n.js'
 import { DEFAULT_SERVER_URL, routes } from './routes.js'
 
@@ -139,6 +140,7 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
     i18n,
     routes,
     collections,
+    hooks: serverHooks,
     db,
     adminStore,
     // Site-wide default storage provider — used by any upload collection
@@ -163,8 +165,7 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
     }),
     // S3-compatible alternative (AWS S3 / Cloudflare R2 / MinIO). Replace
     // the `localStorageProvider` block above with the call below and add
-    // the corresponding `BYLINE_STORAGE_S3_*` entries to your `.env.local`
-    // (see `apps/webapp/.env.local.example`).
+    // the corresponding `BYLINE_STORAGE_S3_*` entries to your `.env.local`.
     //
     // On AWS with an IAM role / instance profile, omit `accessKeyId` and
     // `secretAccessKey` so the SDK resolves credentials via its default
@@ -204,7 +205,7 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
       //
       // We pass `getAdminBylineClient` (not the public client) because
       // admin server fns are the only call sites that read documents in
-      // the admin webapp today — the populate phase inherits whichever
+      // the admin host today — the populate phase inherits whichever
       // actor the request resolved. A future public-facing host would
       // register its own client whose `requestContext` factory resolves
       // an end-user actor instead. See `@byline/host-tanstack-start/

package/dist/templates/host/vite.config.ts

@@ -1,4 +1,5 @@
 import { devtools } from '@tanstack/devtools-vite'
+import { bylineClientHookBoundary } from '@byline/host-tanstack-start/vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
 import tailwindcss from '@tailwindcss/vite'
@@ -158,6 +159,7 @@ const config = defineConfig({
   },
   plugins: [
     browserAsyncHooksAlias(),
+    bylineClientHookBoundary(),
     devtools(),
     nitro({
       preset: 'node',