@byline/cli 2.6.1 → 3.0.0

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

@@ -0,0 +1,262 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type { Root } from 'mdast'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import { unified } from 'unified'
+import { describe, expect, test } from 'vitest'
+
+import { mdastToLexical } from './mdast-to-lexical.js'
+
+function parse(md: string): Root {
+  return unified().use(remarkParse).use(remarkGfm).parse(md) as Root
+}
+
+function convert(md: string) {
+  return mdastToLexical(parse(md))
+}
+
+describe('mdastToLexical', () => {
+  test('empty input yields a single empty paragraph', () => {
+    const { state, warnings } = convert('')
+    expect(warnings).toEqual([])
+    expect(state.root.type).toBe('root')
+    expect(state.root.children).toHaveLength(1)
+    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({
+      type: 'paragraph',
+      children: [{ type: 'text', text: 'hello world', format: 0 }],
+    })
+  })
+
+  test('heading depth maps to tag h1-h6', () => {
+    const { state } = convert('# h1\n\n## h2\n\n###### h6')
+    expect(state.root.children).toHaveLength(3)
+    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 {
+      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 },
+    ])
+  })
+
+  test('strikethrough (GFM) carries the strikethrough bit', () => {
+    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)
+  })
+
+  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
+      listType: string
+      tag: string
+      children: Array<{ type: string; children: Array<{ type: string; text: 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' }],
+    })
+  })
+
+  test('ordered list propagates start and numbers values', () => {
+    const { state } = convert('3. a\n4. b')
+    const list = 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)
+  })
+
+  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 }> }>
+    }
+    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',
+      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
+      language: string
+      children: Array<{ type: string; text?: string }>
+    }
+    expect(code).toMatchObject({ type: 'code', language: '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('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
+      children: Array<{
+        type: string
+        children: Array<{
+          type: string
+          headerState: number
+          children: Array<{ type: string; children: Array<{ text: string }> }>
+        }>
+      }>
+    }
+    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' })
+  })
+
+  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 {
+      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 })
+  })
+
+  test('code fence language is normalized to prism-known ids', () => {
+    const cases: Array<[string, string]> = [
+      ['ts', 'typescript'],
+      ['js', 'javascript'],
+      ['sh', 'bash'],
+      ['yml', 'yaml'],
+      ['tsx', 'tsx'], // already prism-known, passes through
+    ]
+    for (const [input, expected] of cases) {
+      const { state } = convert(`\`\`\`${input}\nx\n\`\`\``)
+      const code = 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 {
+      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?'
+    )
+  })
+})

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

@@ -272,10 +272,15 @@ const LANG_ALIASES: Record<string, string> = {
   xml: 'markup',
 }
 
-function normalizeCodeLang(lang: string | null | undefined): string | null {
-  if (lang == null) return null
+// Default for unfenced / language-less code blocks. Prism crashes on
+// null/undefined languages, and the project's docs are predominantly
+// TypeScript, so fall back to that rather than 'plain'.
+const DEFAULT_CODE_LANG = 'typescript'
+
+function normalizeCodeLang(lang: string | null | undefined): string {
+  if (lang == null) return DEFAULT_CODE_LANG
   const trimmed = lang.trim().toLowerCase()
-  if (trimmed.length === 0) return null
+  if (trimmed.length === 0) return DEFAULT_CODE_LANG
   return LANG_ALIASES[trimmed] ?? trimmed
 }
 

package/dist/templates/byline-examples/scripts/lib/rewrite-doc-links.ts

@@ -0,0 +1,141 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+/**
+ * Rewrite relative markdown links so they work after import.
+ *
+ * Markdown docs commonly link to siblings via `./OTHER.md[#hash]`. Once
+ * imported into Lexical, those hrefs break — Lexical's link serializer
+ * passes them to `new URL(...)` and throws. We rewrite them in-place
+ * against a `sourcePath → importedDocPath` map built in a pre-pass.
+ *
+ * Links whose target isn't in the map (i.e. the .md file wasn't part of
+ * the same import batch) are stripped: the `link` node is replaced by
+ * its inline children, so the reader sees the link text but no broken
+ * URL. The original href is reported as a warning.
+ *
+ * Non-markdown hrefs (absolute URLs, mailto:, pure fragments, images,
+ * etc.) are left untouched.
+ */
+
+import { dirname, resolve } from 'node:path'
+
+import type { Parent, Root, RootContent } from 'mdast'
+
+export interface DocLinkRewriteWarning {
+  kind: 'rewritten-doc-link' | 'unresolved-doc-link' | 'stripped-empty-link'
+  href: string
+  resolvedTo?: string
+}
+
+export interface RewriteDocLinksOptions {
+  /** Absolute path of the markdown file currently being converted. */
+  sourceFilePath: string
+  /** Map from absolute markdown source path → imported doc path (no leading slash). */
+  pathMap: Map<string, string>
+  /** URL prefix the imported docs live under, e.g. `/docs`. */
+  urlPrefix: string
+}
+
+const MD_EXT_RE = /\.(md|markdown)$/i
+// A leading `scheme:` like `https:`, `mailto:`, `data:` — anything we
+// must not touch.
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i
+
+export function rewriteDocLinks(root: Root, opts: RewriteDocLinksOptions): DocLinkRewriteWarning[] {
+  const warnings: DocLinkRewriteWarning[] = []
+  const baseDir = dirname(opts.sourceFilePath)
+  const prefix = opts.urlPrefix.replace(/\/$/, '')
+  rewriteChildren(root as unknown as Parent, baseDir, prefix, opts.pathMap, warnings)
+  return warnings
+}
+
+function rewriteChildren(
+  parent: Parent,
+  baseDir: string,
+  prefix: string,
+  pathMap: Map<string, string>,
+  warnings: DocLinkRewriteWarning[]
+): void {
+  const next: RootContent[] = []
+  for (const child of parent.children as RootContent[]) {
+    if (child.type === 'link') {
+      const decision = classifyLink(child.url, baseDir, pathMap)
+      if (decision.kind === 'skip') {
+        // Still recurse — a link may contain other links via images, etc.
+        rewriteChildren(child as unknown as Parent, baseDir, prefix, pathMap, warnings)
+        next.push(child)
+      } else if (decision.kind === 'rewrite') {
+        const newUrl = `${prefix}/${decision.docPath}${decision.fragment}`
+        warnings.push({
+          kind: 'rewritten-doc-link',
+          href: child.url,
+          resolvedTo: newUrl,
+        })
+        child.url = newUrl
+        rewriteChildren(child as unknown as Parent, baseDir, prefix, pathMap, warnings)
+        next.push(child)
+      } else {
+        // Unresolved .md or empty/meaningless target — drop the link
+        // wrapper, keep the text so the reader still sees the prose.
+        warnings.push({
+          kind: decision.kind === 'unresolved' ? 'unresolved-doc-link' : 'stripped-empty-link',
+          href: child.url,
+        })
+        rewriteChildren(child as unknown as Parent, baseDir, prefix, pathMap, warnings)
+        for (const inner of child.children) next.push(inner as RootContent)
+      }
+    } else {
+      if (hasChildren(child)) {
+        rewriteChildren(child, baseDir, prefix, pathMap, warnings)
+      }
+      next.push(child)
+    }
+  }
+  parent.children = next as Parent['children']
+}
+
+type Decision =
+  | { kind: 'skip' }
+  | { kind: 'rewrite'; docPath: string; fragment: string }
+  | { kind: 'unresolved' }
+  | { kind: 'empty' }
+
+// Targets that reference "the current directory" with no real path —
+// `.`, `..`, `./`, `../`, etc. Authors sometimes write `[text](.)` as a
+// placeholder; in the rendered doc it has no meaning and Lexical's
+// link serializer crashes on it.
+const EMPTY_TARGET_RE = /^\.{1,2}\/?$/
+
+function classifyLink(
+  url: string | undefined | null,
+  baseDir: string,
+  pathMap: Map<string, string>
+): Decision {
+  if (url == null) return { kind: 'skip' }
+  if (url.length === 0) return { kind: 'empty' }
+  if (url.startsWith('#')) return { kind: 'skip' }
+  if (url.startsWith('//')) return { kind: 'skip' }
+  if (SCHEME_RE.test(url)) return { kind: 'skip' }
+
+  const hashIdx = url.indexOf('#')
+  const target = hashIdx >= 0 ? url.slice(0, hashIdx) : url
+  const fragment = hashIdx >= 0 ? url.slice(hashIdx) : ''
+
+  if (target.length === 0 || EMPTY_TARGET_RE.test(target)) return { kind: 'empty' }
+  if (!MD_EXT_RE.test(target)) return { kind: 'skip' }
+
+  const abs = resolve(baseDir, target)
+  const mapped = pathMap.get(abs)
+  if (mapped) return { kind: 'rewrite', docPath: mapped, fragment }
+  return { kind: 'unresolved' }
+}
+
+function hasChildren(node: RootContent): node is RootContent & Parent {
+  return 'children' in node && Array.isArray((node as Parent).children)
+}

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

@@ -0,0 +1,66 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type { Root } from 'mdast'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import { unified } from 'unified'
+import { describe, expect, test } from 'vitest'
+
+import { stripLeadingH1IfMatches } from './strip-leading-h1.js'
+
+function parse(md: string): Root {
+  return unified().use(remarkParse).use(remarkGfm).parse(md) as Root
+}
+
+describe('stripLeadingH1IfMatches', () => {
+  test('removes the leading H1 when its text matches the title', () => {
+    const root = parse('# Authentication & Authorization\n\nbody')
+    const out = stripLeadingH1IfMatches(root, 'Authentication & Authorization')
+    expect(out.children).toHaveLength(1)
+    expect(out.children[0]).toMatchObject({ type: 'paragraph' })
+  })
+
+  test('match is case-insensitive and whitespace-tolerant', () => {
+    const root = parse('#   authentication & authorization   \n\nbody')
+    const out = stripLeadingH1IfMatches(root, 'Authentication & Authorization')
+    expect(out.children).toHaveLength(1)
+  })
+
+  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)
+    expect(out.children[0]).toMatchObject({ type: 'paragraph' })
+  })
+
+  test('leaves the body untouched when the H1 differs', () => {
+    const root = parse('# Different Title\n\nbody')
+    const out = stripLeadingH1IfMatches(root, 'Authentication & Authorization')
+    expect(out.children).toHaveLength(2)
+    expect(out.children[0]).toMatchObject({ type: 'heading', depth: 1 })
+  })
+
+  test('leaves the body untouched when there is no leading heading', () => {
+    const root = parse('just a paragraph')
+    const out = stripLeadingH1IfMatches(root, 'Anything')
+    expect(out.children).toHaveLength(1)
+    expect(out.children[0]).toMatchObject({ type: 'paragraph' })
+  })
+
+  test('leaves the body untouched when the leading heading is H2', () => {
+    const root = parse('## A Subheading\n\nbody')
+    const out = stripLeadingH1IfMatches(root, 'A Subheading')
+    expect(out.children).toHaveLength(2)
+    expect(out.children[0]).toMatchObject({ type: 'heading', depth: 2 })
+  })
+})

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

@@ -0,0 +1,102 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+/**
+ * Bulk re-anchor: move every fully-translated document onto a new content
+ * source locale. This is the follow-up to switching `i18n.content.defaultLocale`
+ * — Slices 1–4 make the switch *safe* (existing docs keep reading their original
+ * anchor); this command actually moves the documents that are complete in the
+ * new locale onto it (its fallback floor, path locale, and completeness
+ * yardstick). Documents not yet fully translated into the target are skipped and
+ * 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
+ *
+ * See docs/DEFAULT-LOCALE-SWITCHING.md.
+ */
+
+import '../load-env.js'
+import '../server.config.js'
+
+import { parseArgs } from 'node:util'
+
+import { getBylineCore, getServerConfig } from '@byline/core'
+import type { PgAdapter } from '@byline/db-postgres'
+
+const USAGE =
+  'Usage: pnpm tsx byline/scripts/re-anchor.ts --to <locale> [--collection <path>] [--dry-run]'
+
+async function run() {
+  const { values } = parseArgs({
+    options: {
+      to: { type: 'string' },
+      collection: { type: 'string' },
+      'dry-run': { type: 'boolean', default: false },
+    },
+  })
+
+  const targetLocale = values.to
+  if (!targetLocale) {
+    console.error(`✗ missing required --to <locale>.\n${USAGE}`)
+    process.exit(1)
+  }
+
+  const config = getServerConfig()
+
+  const contentLocales = config.i18n.content.locales
+  if (!contentLocales.includes(targetLocale)) {
+    console.error(
+      `✗ --to '${targetLocale}' is not a configured content locale (${contentLocales.join(', ')})`
+    )
+    process.exit(1)
+  }
+
+  // Resolve an optional collection-path filter to its id via the registered
+  // collection records (throws a clear error for an unknown path).
+  const collectionPath = values.collection
+  const collectionId = collectionPath
+    ? getBylineCore().getCollectionRecord(collectionPath).collectionId
+    : undefined
+
+  const dryRun = values['dry-run'] ?? false
+  const db = config.db as PgAdapter
+  const scope = collectionPath ? `collection '${collectionPath}'` : 'all collections'
+
+  console.log(
+    `${dryRun ? '[dry-run] ' : ''}re-anchoring ${scope} → content source locale '${targetLocale}'…`
+  )
+
+  const report = await db.reAnchorDocuments({ targetLocale, collectionId, dryRun })
+
+  console.log(
+    `${dryRun ? '[dry-run] would re-anchor' : '✓ re-anchored'} ${report.reanchored}/${report.total} document(s) → '${targetLocale}'`
+  )
+  console.log(`  • already anchored to '${targetLocale}': ${report.alreadyAnchored}`)
+  console.log(`  • skipped (incomplete translation): ${report.skippedIncomplete}`)
+
+  if (report.skippedIncomplete > 0) {
+    console.log(
+      `\nDocuments needing a complete '${targetLocale}' translation before they can be re-anchored:`
+    )
+    for (const r of report.results) {
+      if (r.status === 'skipped-incomplete') {
+        console.log(`  - ${r.documentId} (currently anchored to '${r.fromLocale}')`)
+      }
+    }
+  }
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error('✗ re-anchor failed:', error)
+    process.exit(1)
+  })

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

@@ -18,7 +18,7 @@
  * to `'avif'` in `byline/collections/media/schema.ts`) to bring existing
  * assets in line with the new pipeline:
  *
- *   pnpm tsx --env-file=.env --env-file=.env.local byline/scripts/regenerate-media.ts
+ *   pnpm tsx byline/scripts/regenerate-media.ts
  *
  * The script orchestrates the same two-step flow the admin UI uses
  * for an existing document — upload (createDocument: false) followed by