@byline/cli 3.21.0 → 4.1.0

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-operation.ts

@@ -0,0 +1,112 @@
+/**
+ * Maintenance helpers for `regenerate-media.ts`.
+ *
+ * Kept separate from the executable so the safety-critical behaviour can be
+ * unit tested without loading the application server config or touching real
+ * storage.
+ */
+
+import type { CollectionHandle } from '@byline/client'
+import {
+  getDefaultStatus,
+  getWorkflowStatuses,
+  type CollectionDefinition,
+  type IDbAdapter,
+  type StoredFileValue,
+} from '@byline/core'
+
+export function storedFilePaths(value: StoredFileValue): Set<string> {
+  return new Set([
+    value.storagePath,
+    ...(value.variants ?? [])
+      .map((variant) => variant.storagePath)
+      .filter((storagePath): storagePath is string => Boolean(storagePath)),
+  ])
+}
+
+/**
+ * Reject a partial image-processor result before it replaces a complete
+ * persisted value. Core uploads deliberately tolerate an individual variant
+ * failure for interactive requests; this maintenance operation must be
+ * stricter because it is about bringing every stored asset up to the schema.
+ */
+export function assertCompleteVariantSet(
+  storedFile: StoredFileValue,
+  expectedVariantNames: readonly string[]
+): void {
+  const expected = [...expectedVariantNames].sort()
+  const actual = (storedFile.variants ?? []).map((variant) => variant.name).sort()
+  if (
+    expected.length !== actual.length ||
+    expected.some((variantName, index) => variantName !== actual[index])
+  ) {
+    throw new Error(
+      `regenerate-media: incomplete variant set for '${storedFile.storagePath}' ` +
+        `(expected: ${expected.join(', ') || 'none'}; generated: ${actual.join(', ') || 'none'}).`
+    )
+  }
+}
+
+/**
+ * Write the regenerated fields and restore the captured workflow status as
+ * one transaction.
+ *
+ * `CollectionHandle.update()` creates a new immutable version at the
+ * collection's default status. For this maintenance operation, changing that
+ * newly-created row to the captured status inside the same transaction is not
+ * an editorial transition: no caller can observe the intermediate draft, and
+ * an archived item never passes through published. The final version row and
+ * its normal `document.updated` activity entry retain the resulting status;
+ * the explicit status mutation is additionally audited as a system action.
+ *
+ * Direct adapter commands are intentional here and should not be copied into
+ * ordinary application writes. Scripts are the supported escape hatch for
+ * migrations that must preserve metadata while still using the lifecycle for
+ * the content update itself.
+ */
+export async function replaceMediaVersionPreservingStatus(params: {
+  db: IDbAdapter
+  definition: CollectionDefinition
+  collectionId: string
+  handle: Pick<CollectionHandle, 'update'>
+  documentId: string
+  fields: Record<string, any>
+  targetStatus: string
+}): Promise<{ documentVersionId: string }> {
+  const statuses = getWorkflowStatuses(params.definition).map((status) => status.name)
+  if (!statuses.includes(params.targetStatus)) {
+    throw new Error(
+      `regenerate-media: status '${params.targetStatus}' is not declared on collection ` +
+        `'${params.definition.path}' (declared: ${statuses.join(', ')}).`
+    )
+  }
+
+  const defaultStatus = getDefaultStatus(params.definition)
+  return params.db.withTransaction(async () => {
+    const result = await params.handle.update(params.documentId, params.fields)
+    if (params.targetStatus === defaultStatus) return result
+
+    await params.db.commands.documents.setDocumentStatus({
+      document_version_id: result.documentVersionId,
+      status: params.targetStatus,
+    })
+    if (params.targetStatus === 'published') {
+      await params.db.commands.documents.archivePublishedVersions({
+        document_id: params.documentId,
+        excludeVersionId: result.documentVersionId,
+      })
+    }
+    await params.db.commands.audit.append({
+      documentId: params.documentId,
+      collectionId: params.collectionId,
+      actorId: null,
+      actorRealm: 'system',
+      action: 'document.status.changed',
+      field: 'status',
+      before: defaultStatus,
+      after: params.targetStatus,
+    })
+
+    return result
+  })
+}