@crombolo/server 0.13.2 → 0.14.1

package/src/site-replace.ts

@@ -0,0 +1,188 @@
+/**
+ * Replacing a site with a whole-site file (story 105): what has to be true
+ * before it starts, and what the site has that the file does not.
+ *
+ * `--replace` recycles content and media the file does not carry, so a revert
+ * brings them back, and keeps the site's people. `--replace-all` deletes them,
+ * and the members and users the file does not carry too.
+ */
+import { existsSync } from 'node:fs'
+import { join, sep } from 'node:path'
+import { discoverBundles } from '@crombolo/backoffice-host'
+import {
+  currentSchemaState,
+  type Db,
+  DocumentRepository,
+  MemberRepository,
+  ObjectTypes,
+  TransferRunRepository,
+  UserRepository,
+} from '@crombolo/data'
+import type { BundleManifest, BundlePeople, ContentSet } from '@crombolo/transfer'
+
+export type ReplaceMode = 'replace' | 'replace-all'
+
+/**
+ * The server bundles a file needs and this site lacks, or has older, each
+ * named with the version wanted.
+ */
+export function requiresProblems(manifest: BundleManifest, siteDir: string): string[] {
+  const required = Object.entries(manifest.requires ?? {})
+  if (required.length === 0) return []
+  const installed = new Map(
+    discoverBundles(siteDir).bundles.map((found) => [found.packageName, found.version]),
+  )
+  const problems: string[] = []
+  for (const [name, version] of required) {
+    const here = installed.get(name)
+    if (!here) problems.push(`the file needs ${name}@${version}, which this site does not have`)
+    else if (Bun.semver.order(here, version) < 0)
+      problems.push(`the file needs ${name}@${version}, and this site has ${here}`)
+  }
+  return problems
+}
+
+/** Whether the file's people include someone who can administer the back office. */
+export function carriesAdministrator(people: BundlePeople | undefined): boolean {
+  return (people?.users ?? []).some((user) => !user.disabled && user.groupAliases.includes('admin'))
+}
+
+const PRUNED_KINDS = [
+  { objectType: ObjectTypes.Document, kind: 'document' },
+  { objectType: ObjectTypes.Media, kind: 'media' },
+  { objectType: ObjectTypes.Element, kind: 'element' },
+  { objectType: ObjectTypes.DocumentBlueprint, kind: 'blueprint' },
+] as const
+
+export interface PrunedNode {
+  key: string
+  kind: (typeof PRUNED_KINDS)[number]['kind']
+  head: number | undefined
+  published: number | undefined
+}
+
+/**
+ * Takes out what the site has and the file does not: the topmost of each such
+ * branch, recycled or deleted, inside the caller's transaction. Answers what
+ * was recycled, for the run to record so its revert can bring it back.
+ */
+export async function pruneSite(
+  tx: Db,
+  set: ContentSet,
+  mode: ReplaceMode,
+  nodeId: string,
+): Promise<PrunedNode[]> {
+  const inFile = new Set(set.nodes.map((node) => node.key.toLowerCase()))
+  const state = await currentSchemaState(tx)
+  const nodeState = { version: state.version, revision: state.revision }
+  const pruned: PrunedNode[] = []
+  for (const { objectType, kind } of PRUNED_KINDS) {
+    const rows = await tx.query<{ id: number; unique_id: string; parent_id: number }>(
+      'SELECT id, unique_id, parent_id FROM node WHERE node_object_type = ? AND trashed = ?',
+      [objectType, tx.dialect.boolValue(false)],
+    )
+    const leaving = rows.filter((row) => !inFile.has(String(row.unique_id).toLowerCase()))
+    const leavingIds = new Set(leaving.map((row) => Number(row.id)))
+    // The top of each branch: recycling or deleting it takes its children too.
+    const tops = leaving.filter((row) => !leavingIds.has(Number(row.parent_id)))
+    const repo = new DocumentRepository(tx, { kind, nodeState, nodeId, inTreeLock: true })
+    for (const row of tops) {
+      const key = String(row.unique_id)
+      if (mode === 'replace-all') {
+        await repo.delete(key)
+        continue
+      }
+      const markers = await repo.eventMarkers(key)
+      await repo.moveToRecycleBin(key)
+      pruned.push({ key, kind, head: markers?.head, published: markers?.published })
+    }
+  }
+  return pruned
+}
+
+/** Members and users the file does not carry, deleted: `--replace-all` only. */
+export async function prunePeople(tx: Db, people: BundlePeople | undefined): Promise<void> {
+  const members = new Set((people?.members ?? []).map((m) => m.key.toLowerCase()))
+  const users = new Set((people?.users ?? []).map((u) => u.key.toLowerCase()))
+  const state = await currentSchemaState(tx)
+  const memberRepo = new MemberRepository(tx, {
+    nodeState: { version: state.version, revision: state.revision },
+  })
+  const memberRows = await tx.query<{ unique_id: string }>(
+    'SELECT unique_id FROM node WHERE node_object_type = ?',
+    [ObjectTypes.Member],
+  )
+  for (const row of memberRows)
+    if (!members.has(String(row.unique_id).toLowerCase()))
+      await memberRepo.delete(String(row.unique_id))
+  const userRepo = new UserRepository(tx)
+  for (const row of await tx.query<{ key: string }>('SELECT key FROM user_account'))
+    if (!users.has(String(row.key).toLowerCase())) await userRepo.delete(String(row.key))
+}
+
+/** Records what a replace recycled on its run, so `content revert` brings it back. */
+export async function recordPruned(tx: Db, runId: string, pruned: PrunedNode[]): Promise<void> {
+  const runs = new TransferRunRepository(tx)
+  for (const node of pruned)
+    await runs.record({
+      runId,
+      nodeKey: node.key,
+      kind: node.kind,
+      action: 'recycle',
+      beforeEventId: node.head ?? null,
+      beforePublishedEventId: node.published ?? null,
+      eventId: null,
+    })
+}
+
+export interface ReplaceSummary {
+  /** What the site has that the file does not, by kind: recycled, or deleted. */
+  leaving: Record<string, number>
+  /** Files in the site's folders that the file does not carry. */
+  filesRemoved: string[]
+  /** Members and users `--replace-all` would delete. */
+  people: { members: number; users: number }
+}
+
+/** Read-only: what replacing this site with the file would take out. */
+export async function replaceSummary(
+  db: Db,
+  set: ContentSet,
+  carriedPaths: ReadonlySet<string>,
+  folders: ReadonlyArray<{ section: string; dir: string }>,
+  mode: ReplaceMode,
+): Promise<ReplaceSummary> {
+  const inFile = new Set(set.nodes.map((node) => node.key.toLowerCase()))
+  const leaving: Record<string, number> = {}
+  for (const { objectType, kind } of PRUNED_KINDS) {
+    const rows = await db.query<{ unique_id: string }>(
+      'SELECT unique_id FROM node WHERE node_object_type = ? AND trashed = ?',
+      [objectType, db.dialect.boolValue(false)],
+    )
+    const count = rows.filter((row) => !inFile.has(String(row.unique_id).toLowerCase())).length
+    if (count > 0) leaving[kind] = count
+  }
+  const filesRemoved: string[] = []
+  for (const { section, dir } of folders) {
+    if (!existsSync(dir)) continue
+    for (const path of new Bun.Glob('**/*').scanSync({ cwd: dir, onlyFiles: true })) {
+      const bundlePath = `${section}/${path.split(sep).join('/')}`
+      if (!carriedPaths.has(bundlePath)) filesRemoved.push(join(dir, path))
+    }
+  }
+  let people = { members: 0, users: 0 }
+  if (mode === 'replace-all') {
+    const members = new Set((set.people?.members ?? []).map((m) => m.key.toLowerCase()))
+    const users = new Set((set.people?.users ?? []).map((u) => u.key.toLowerCase()))
+    const memberRows = await db.query<{ unique_id: string }>(
+      'SELECT unique_id FROM node WHERE node_object_type = ?',
+      [ObjectTypes.Member],
+    )
+    const userRows = await db.query<{ key: string }>('SELECT key FROM user_account')
+    people = {
+      members: memberRows.filter((r) => !members.has(String(r.unique_id).toLowerCase())).length,
+      users: userRows.filter((r) => !users.has(String(r.key).toLowerCase())).length,
+    }
+  }
+  return { leaving, filesRemoved, people }
+}

package/src/site-search.ts

@@ -0,0 +1,51 @@
+/**
+ * Site search for a render (story 140): the published-only index, narrowed to
+ * what the person asking may open, each hit read back from the published cache
+ * so a page unpublished since it was indexed is never shown. docs/search.md.
+ */
+import { branchAccess } from '@crombolo/core'
+import { type Db, PublicAccessRepository, SiteSearch } from '@crombolo/data'
+import {
+  excerpt,
+  type PublishedCache,
+  type RequestMember,
+  type SearchResult,
+  type SiteSearchPort,
+} from '@crombolo/render'
+
+/** The search `search()` calls during one render, for `member` or for nobody signed in. */
+export function siteSearchFor(
+  db: Db,
+  cache: PublishedCache,
+  member: RequestMember | undefined,
+): SiteSearchPort {
+  return async (query, options) => {
+    const rules = await new PublicAccessRepository(db).allRules()
+    const access = branchAccess(
+      rules,
+      member ? { username: member.username, groups: member.roles } : undefined,
+    )
+    const culture = options.culture ?? (await cache.defaultCulture())
+    const hits = await new SiteSearch(db).query(query, {
+      culture: culture ?? '',
+      types: options.types,
+      skip: options.skip,
+      take: options.take,
+      access,
+    })
+    const nav = await cache.navigation(culture)
+    const items: SearchResult[] = []
+    for (const hit of hits.items) {
+      const content = nav.byKey(hit.key)
+      if (!content) continue
+      items.push({
+        content,
+        url: content.url,
+        name: content.name,
+        score: hit.score,
+        excerpt: excerpt(hit.text, query),
+      })
+    }
+    return { total: hits.total, items }
+  }
+}

package/src/site-sections.ts

@@ -0,0 +1,234 @@
+/**
+ * The sections a bundle carries beyond its content — schema, components,
+ * styles, scripts and the dictionary — gathered from a site. One place, so the
+ * backoffice's Packages builder (picked items) and `crombolo export --site`
+ * (everything) compose a bundle the same way. `docs/bundles.md`.
+ */
+import { readdir, readFile } from 'node:fs/promises'
+import { join, relative, sep } from 'node:path'
+import type { FileSystemPort } from '@crombolo/api-management'
+import {
+  type ComponentFileStore,
+  ComponentRepository,
+  currentSchemaState,
+  type Db,
+  DictionaryRepository,
+} from '@crombolo/data'
+import {
+  exportSchemaSet,
+  fileNameFor,
+  type SchemaSet,
+  writeContentType,
+  writeDataType,
+  writeLanguages,
+  writeMediaType,
+  writeSchemaVersion,
+} from '@crombolo/schema'
+import { BUNDLE_SECTIONS, type BundleFile, type BundleSection } from '@crombolo/transfer'
+import { dictionaryToUdt, writeDictionaryUdt } from './dictionary-transfer.ts'
+
+export interface SiteSectionSources {
+  db: Db
+  /** Reads a template's view, which lives on disk rather than in the row. */
+  componentFiles: ComponentFileStore
+  components?: FileSystemPort
+  stylesheets?: FileSystemPort
+  scripts?: FileSystemPort
+  /** The schema directory, read whole for `'all'`: the files are the schema. */
+  schemaDir?: string
+}
+
+/** What a Packages definition picks, by key or alias as the backoffice sends them. */
+export interface SectionPicks {
+  contentTypes: readonly string[]
+  mediaTypes: readonly string[]
+  dataTypes: readonly string[]
+  languages: readonly string[]
+  /** Template aliases and paths in the components tree, in one list. */
+  components: readonly string[]
+  stylesheets: readonly string[]
+  scripts: readonly string[]
+  dictionaryItems: readonly string[]
+}
+
+/** Matches a selection against a type's key or its alias, since the UI sends either. */
+const picks = (selected: readonly string[]) => {
+  const wanted = new Set(selected.map((value) => value.trim().toLowerCase()))
+  return (type: { key?: string; alias: string }): boolean =>
+    wanted.has(type.alias.toLowerCase()) ||
+    (type.key !== undefined && wanted.has(type.key.toLowerCase()))
+}
+
+/** The selected slice of the site's schema, as the files `schema/` would hold. */
+function schemaEntries(set: SchemaSet, from: SectionPicks): BundleFile[] {
+  const entries: BundleFile[] = []
+  const put = (path: string, text: string) =>
+    entries.push({ path: `${BUNDLE_SECTIONS.schema}/${path}`, text })
+
+  const contentTypes = set.contentTypes.filter(picks(from.contentTypes))
+  const mediaTypes = (set.mediaTypes ?? []).filter(picks(from.mediaTypes))
+  // Member types have no picker in the builder, and the contract's definition
+  // has no field for them, so a picked bundle never carries one.
+  const dataTypes = set.dataTypes.filter(picks(from.dataTypes))
+  const languages = set.languages.filter((language) =>
+    from.languages.some((pick) => pick.toLowerCase() === language.iso.toLowerCase()),
+  )
+
+  if (
+    contentTypes.length === 0 &&
+    mediaTypes.length === 0 &&
+    dataTypes.length === 0 &&
+    languages.length === 0
+  )
+    return entries
+
+  put('schema.toml', writeSchemaVersion(set.version))
+  for (const type of contentTypes)
+    put(join('content-types', fileNameFor(type.alias)), writeContentType(type))
+  for (const type of mediaTypes)
+    put(join('media-types', fileNameFor(type.alias)), writeMediaType(type))
+  for (const type of dataTypes)
+    put(join('data-types', fileNameFor(type.alias)), writeDataType(type))
+  if (languages.length > 0) put('languages.toml', writeLanguages(languages))
+  return entries
+}
+
+/** Every `.toml` under the schema directory, as it stands: the whole site's schema. */
+async function wholeSchema(dir: string | undefined): Promise<BundleFile[]> {
+  if (!dir) return []
+  const files: BundleFile[] = []
+  const walk = async (at: string): Promise<void> => {
+    let entries: import('node:fs').Dirent[]
+    try {
+      entries = await readdir(at, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const path = join(at, entry.name)
+      if (entry.isDirectory()) await walk(path)
+      else if (entry.name.toLowerCase().endsWith('.toml'))
+        files.push({
+          path: `${BUNDLE_SECTIONS.schema}/${relative(dir, path).split(sep).join('/')}`,
+          text: await readFile(path, 'utf8'),
+        })
+    }
+  }
+  await walk(dir)
+  return files
+}
+
+/** Every file a file area holds, by its path within the area. */
+async function everyPath(port: FileSystemPort | undefined): Promise<string[]> {
+  if (!port) return []
+  const paths: string[] = []
+  const walk = async (parent: string | null): Promise<void> => {
+    for (const entry of (await port.children(parent)) ?? []) {
+      if (entry.isFolder) await walk(entry.path)
+      else paths.push(entry.path)
+    }
+  }
+  await walk(null)
+  return paths
+}
+
+/**
+ * The files a selection of file-system paths resolves to, under one section.
+ *
+ * The section is a logical name — `styles`, not `css` — because a site holds
+ * these wherever it is configured to, and the importer is what maps a section
+ * onto a directory.
+ */
+async function fileEntries(
+  port: FileSystemPort | undefined,
+  paths: readonly string[],
+  section: BundleSection,
+): Promise<BundleFile[]> {
+  if (!port) return []
+  const files: BundleFile[] = []
+  for (const path of paths) {
+    const file = await port.read(path)
+    if (!file) continue
+    const within = file.path.replace(/^\/+/, '')
+    files.push({ path: `${BUNDLE_SECTIONS[section]}/${within}`, text: file.content })
+  }
+  return files
+}
+
+async function componentEntries(
+  sources: SiteSectionSources,
+  keys: readonly string[],
+): Promise<BundleFile[]> {
+  if (keys.length === 0) return []
+  const templates = new ComponentRepository(sources.db, sources.componentFiles)
+  const wanted = new Set(keys.map((key) => key.trim().toLowerCase()))
+  const files: BundleFile[] = []
+  for (const template of await templates.all()) {
+    if (!wanted.has(template.key.toLowerCase()) && !wanted.has(template.alias.toLowerCase()))
+      continue
+    files.push({
+      path: `${BUNDLE_SECTIONS.components}/${template.alias}.tsx`,
+      text: template.content ?? '',
+    })
+  }
+  return files
+}
+
+/**
+ * The components a bundle carries, from one list that holds two kinds of name.
+ *
+ * The contract has `templates` and `partialViews`; this side has one list, so a
+ * picked component arrives either as a template alias — read through the alias
+ * — or as a path in the components tree. Both are tried and the results are
+ * keyed by path, so a component picked both ways is carried once.
+ */
+async function componentSection(
+  sources: SiteSectionSources,
+  picked: readonly string[],
+): Promise<BundleFile[]> {
+  const byPath = new Map<string, BundleFile>()
+  for (const file of await componentEntries(sources, picked)) byPath.set(file.path, file)
+  for (const file of await fileEntries(sources.components, picked, 'components'))
+    byPath.set(file.path, file)
+  return [...byPath.values()]
+}
+
+/** The dictionary as one `.udt`: the picked items, or every root item when none are named. */
+async function dictionaryEntries(db: Db, keys: readonly string[] | 'all'): Promise<BundleFile[]> {
+  const repo = new DictionaryRepository(db)
+  const items =
+    keys === 'all'
+      ? await dictionaryToUdt(repo)
+      : (await Promise.all(keys.map((key) => dictionaryToUdt(repo, key)))).flat()
+  if (items.length === 0) return []
+  return [{ path: `${BUNDLE_SECTIONS.dictionary}.udt`, text: writeDictionaryUdt(items) }]
+}
+
+/** The picked sections, or with `'all'` every one of them in full. */
+export async function siteSections(
+  sources: SiteSectionSources,
+  selection: SectionPicks | 'all',
+): Promise<BundleFile[]> {
+  if (selection === 'all') {
+    return [
+      ...(await wholeSchema(sources.schemaDir)),
+      ...(await fileEntries(sources.components, await everyPath(sources.components), 'components')),
+      ...(await fileEntries(sources.stylesheets, await everyPath(sources.stylesheets), 'styles')),
+      ...(await fileEntries(sources.scripts, await everyPath(sources.scripts), 'scripts')),
+      ...(await dictionaryEntries(sources.db, 'all')),
+    ]
+  }
+  // The schema version the site is actually at, so the files a package carries
+  // say where they came from rather than claiming version 0.
+  const state = await currentSchemaState(sources.db).catch(() => undefined)
+  const schema = await exportSchemaSet(sources.db, state?.version ?? '0')
+  return [
+    ...schemaEntries(schema, selection),
+    ...(await componentSection(sources, selection.components)),
+    ...(await fileEntries(sources.stylesheets, selection.stylesheets, 'styles')),
+    ...(await fileEntries(sources.scripts, selection.scripts, 'scripts')),
+    ...(selection.dictionaryItems.length > 0
+      ? await dictionaryEntries(sources.db, selection.dictionaryItems)
+      : []),
+  ]
+}

package/src/tar.ts

@@ -7,6 +7,12 @@
  * `Bun.gzipSync` does the compression. Timestamps are fixed, as npm fixes them,
  * so the same selection packs to the same bytes.
  */
+import { once } from 'node:events'
+import { createReadStream, createWriteStream, type WriteStream } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { pipeline } from 'node:stream/promises'
+import { createGunzip, createGzip, type Gzip } from 'node:zlib'
 
 export interface TarEntry {
   /** The path inside the package, `/`-separated and never absolute. */
@@ -83,3 +89,152 @@ export function writeNpmTarball(entries: readonly TarEntry[]): Uint8Array<ArrayB
   }
   return Bun.gzipSync(tar) as Uint8Array<ArrayBuffer>
 }
+
+const padding = (size: number) => (BLOCK - (size % BLOCK)) % BLOCK
+
+const checkInside = (path: string) => {
+  if (path.startsWith('/') || path.split('/').includes('..'))
+    throw new Error(`${path} is not a path inside the package`)
+}
+
+/**
+ * An npm package tarball written as it goes (story 104), for a package too big
+ * to hold in memory: entries are gzipped straight to the file, and a file's
+ * bytes may arrive as a stream. The layout is `writeNpmTarball`'s.
+ */
+export class TarballWriter {
+  #gzip: Gzip
+  #done: Promise<void>
+
+  private constructor(file: string) {
+    this.#gzip = createGzip()
+    const out = createWriteStream(file)
+    this.#done = pipeline(this.#gzip, out)
+  }
+
+  static create(file: string): TarballWriter {
+    return new TarballWriter(file)
+  }
+
+  async #write(bytes: Uint8Array): Promise<void> {
+    if (!this.#gzip.write(bytes)) await once(this.#gzip, 'drain')
+  }
+
+  async add(path: string, bytes: Uint8Array): Promise<void> {
+    checkInside(path)
+    await this.#write(header(`package/${path}`, bytes.length))
+    await this.#write(bytes)
+    const pad = padding(bytes.length)
+    if (pad > 0) await this.#write(new Uint8Array(pad))
+  }
+
+  /** A file whose `size` is known and whose bytes arrive in chunks; refused if they come to another size. */
+  async addStream(path: string, size: number, chunks: AsyncIterable<Uint8Array>): Promise<void> {
+    checkInside(path)
+    await this.#write(header(`package/${path}`, size))
+    let written = 0
+    for await (const chunk of chunks) {
+      written += chunk.length
+      if (written > size) throw new Error(`${path} is larger than its declared ${size} bytes`)
+      await this.#write(chunk)
+    }
+    if (written !== size) throw new Error(`${path} was ${written} bytes, not ${size}`)
+    const pad = padding(size)
+    if (pad > 0) await this.#write(new Uint8Array(pad))
+  }
+
+  async close(): Promise<void> {
+    await this.#write(new Uint8Array(BLOCK * 2))
+    this.#gzip.end()
+    await this.#done
+  }
+}
+
+const decoder = new TextDecoder()
+
+const field = (block: Uint8Array, offset: number, width: number) =>
+  decoder.decode(block.subarray(offset, offset + width)).replace(/\0.*$/s, '')
+
+/**
+ * Unpacks a gzipped tarball into `dir`, streaming, and answers the paths it
+ * wrote. npm's `package/` folder is dropped, so `dir` holds what the package
+ * holds. Only regular files are written; a path that climbs out is refused.
+ */
+export async function extractTarball(file: string, dir: string): Promise<string[]> {
+  const written: string[] = []
+  let pending = new Uint8Array(0)
+  let current: { out: WriteStream; left: number; skip: number } | undefined
+  let skipping = 0
+  let ended = false
+
+  const take = (n: number): Uint8Array | undefined => {
+    if (pending.length < n) return undefined
+    const head = pending.subarray(0, n)
+    pending = pending.subarray(n)
+    return head
+  }
+
+  const writeTo = async (out: WriteStream, bytes: Uint8Array) => {
+    if (!out.write(bytes)) await once(out, 'drain')
+  }
+
+  const finishEntry = async (out: WriteStream) => {
+    out.end()
+    await once(out, 'finish')
+  }
+
+  for await (const chunk of createReadStream(file).pipe(createGunzip())) {
+    const bytes = chunk as Uint8Array
+    const joined = new Uint8Array(pending.length + bytes.length)
+    joined.set(pending)
+    joined.set(bytes, pending.length)
+    pending = joined
+    while (!ended) {
+      if (current) {
+        if (current.left > 0) {
+          if (pending.length === 0) break
+          const part = pending.subarray(0, Math.min(current.left, pending.length))
+          pending = pending.subarray(part.length)
+          current.left -= part.length
+          await writeTo(current.out, part)
+          continue
+        }
+        skipping = current.skip
+        await finishEntry(current.out)
+        current = undefined
+      }
+      if (skipping > 0) {
+        const part = Math.min(skipping, pending.length)
+        pending = pending.subarray(part)
+        skipping -= part
+        if (skipping > 0) break
+      }
+      const block = take(BLOCK)
+      if (!block) break
+      if (block.every((byte) => byte === 0)) {
+        ended = true
+        break
+      }
+      const name = field(block, 0, 100)
+      const prefix = field(block, 345, 155)
+      const size = Number.parseInt(field(block, 124, 12).trim() || '0', 8)
+      const type = String.fromCharCode(block[156] ?? 48)
+      const full = prefix ? `${prefix}/${name}` : name
+      if (type !== '0' && type !== '\0') {
+        skipping = size + padding(size)
+        continue
+      }
+      const inside = full.replace(/^package\//, '')
+      checkInside(inside)
+      const target = join(dir, ...inside.split('/'))
+      await mkdir(dirname(target), { recursive: true })
+      written.push(inside)
+      current = { out: createWriteStream(target), left: size, skip: padding(size) }
+    }
+  }
+  if (current) {
+    if (current.left > 0) throw new Error(`${file} ends part-way through a file`)
+    await finishEntry(current.out)
+  }
+  return written
+}