@crombolo/cli 0.13.2 → 0.14.1

package/bin/crombolo.ts

@@ -6,6 +6,7 @@
  *   crombolo start                  boot the site; resets and prints the admin password
  *   crombolo start --keep-admin     boot without touching the admin password
  *   crombolo start --bundle <pkg>   apply a bundle's content, once, then serve
+ *   crombolo start --from <file>    in an empty folder: a working site from a whole-site file
  *   crombolo init                   scaffold a site in the current directory
  *   crombolo init --template <id>   …from a starter template, content included
  *   crombolo status                 what this environment is, without starting it
@@ -20,6 +21,7 @@
  *   crombolo components check       compile every component before a visitor does
  *   crombolo assets list            the stylesheets and scripts beside them
  *
+ *   crombolo export --site          write the whole site to one file, to move it to another machine or host
  *   crombolo content export         write a subtree as a private bundle package, to move to another environment
  *   crombolo content check          read-only: what installing a bundle's content here would do
  *   crombolo content import         apply a bundle's content, in one transaction, and record the run
@@ -29,6 +31,7 @@
  *   crombolo domains                the hostnames this site answers on
  *   crombolo domains set            write domains.toml and apply it
  *
+ *   crombolo import <file>          replace this site with a whole-site file; says what first
  *   crombolo import umbraco report  read-only: what importing an Umbraco backup would and would not bring
  *   crombolo import umbraco apply   write a crombolo site from an Umbraco backup
  *
@@ -213,7 +216,91 @@ function stopOnSignal(
   for (const signal of ['SIGINT', 'SIGTERM'] as const) process.on(signal, () => stop(signal))
 }
 
+/**
+ * `start --from <file>` (story 105): an empty folder in, a working site out —
+ * scaffolded as `init` scaffolds one, its packages installed, and the file
+ * imported as a replace so nothing of the scaffold's own starting point stays.
+ * The new administrator's password is printed here, once.
+ */
+async function startFromFile(from: string): Promise<void> {
+  const file = resolve(cwd, from)
+  if (!existsSync(file)) {
+    console.error(`${from} does not exist.`)
+    process.exit(1)
+  }
+  if (existsSync(join(cwd, 'crombolo.config.ts'))) {
+    console.error(
+      'There is a site here already. `crombolo import <file> --replace` replaces it; start --from starts a new one in an empty folder.',
+    )
+    process.exit(1)
+  }
+  const dir = await ops.unpackBundle(file, cwd)
+  const manifest = ops.readBundle(dir, cwd).set.manifest
+  if (manifest.scope !== 'site') {
+    console.error(`${from} is not a whole-site file: write one with \`crombolo export --site\`.`)
+    process.exit(1)
+  }
+  const passphrase = manifest.people
+    ? (process.env[PASSPHRASE_ENV] ??
+      (process.stdin.isTTY ? await readSecret('  Passphrase for its people: ') : undefined))
+    : undefined
+  if (manifest.people && !passphrase) {
+    console.error(`${from} carries people, sealed: set ${PASSPHRASE_ENV} to its passphrase.`)
+    process.exit(1)
+  }
+
+  for (const scaffolded of scaffoldFiles({
+    siteName: flagValue('--name') ?? manifest.provenance.siteName,
+    postgres: flags.has('--postgres'),
+  })) {
+    const target = join(cwd, scaffolded.path)
+    if (existsSync(target)) continue
+    await mkdir(join(target, '..'), { recursive: true })
+    if (scaffolded.copyFrom === undefined) await writeFile(target, scaffolded.text ?? '')
+    else await Bun.write(target, Bun.file(scaffolded.copyFrom))
+  }
+  console.log(`  scaffolded a site for ${manifest.provenance.siteName || 'the file'}`)
+  if (!flags.has('--no-install')) {
+    const install = Bun.spawnSync(['bun', 'install'], { cwd, stdout: 'inherit', stderr: 'inherit' })
+    if (install.exitCode !== 0) {
+      console.error('`bun install` failed; run it, then `crombolo import <file> --replace`.')
+      process.exit(1)
+    }
+  }
+
+  const config = await siteConfig()
+  const { db, seededAdminPassword } = await bootstrapDatabase(config)
+  await db.close()
+  const result = await ops.contentImport(config, {
+    bundle: dir,
+    passphrase,
+    replace: 'replace',
+    allowMissingBlobs: flags.has('--allow-missing-media'),
+    backupTaken: true,
+    label: `start --from ${basename(file)}`,
+  })
+  for (const problem of result.problems) console.error(`  ${problem}`)
+  if (!result.runId) {
+    printTransferFindings(result.check)
+    console.error('\nThe file could not be imported; the scaffolded site is left as it is.')
+    process.exit(1)
+  }
+  console.log(`  imported ${result.check.counts.create} item(s), run ${result.runId}`)
+  const placed = describePlaced(result.blobs)
+  if (placed) console.log(`  media    ${placed}`)
+  if (seededAdminPassword)
+    banner([
+      'Sign in with (shown once)',
+      `  username  ${config.adminLogin}`,
+      `  password  ${seededAdminPassword}`,
+    ])
+  // The password above is the one to use: this first start leaves it alone.
+  flags.add('--keep-admin')
+}
+
 async function start(): Promise<void> {
+  const from = flagValue('--from')
+  if (from) await startFromFile(from)
   const config = await siteConfig()
   // Before the migration and the seed, so a clash with the container stack is
   // reported in a second rather than after the database work.
@@ -1145,10 +1232,12 @@ async function contentRevert(config: CromboloConfig): Promise<void> {
     // The files an install replaced come back from the run's own copies, not
     // from git: these files are editable in the backoffice, so a site need not
     // be a checkout at all.
-    const files = ops.restoreSectionFiles(config, runId)
+    const files = await ops.revertSections(db, config, runId)
     for (const file of files.restored) console.log(`  restored ${relative(cwd, file)}`)
     for (const file of files.removed)
       console.log(`  removed  ${relative(cwd, file)}  (created by that run)`)
+    if (files.schema) console.log(`  schema   ${files.schema}`)
+    if (files.dictionary) console.log('  restored the dictionary')
 
     for (const key of result.restored) console.log(`  restored ${key}`)
     for (const key of result.recycled) console.log(`  recycled ${key}  (created by that run)`)
@@ -1269,27 +1358,10 @@ async function contentImport(config: CromboloConfig): Promise<void> {
 
   if (!result.runId) {
     printTransferFindings(result.check)
-    // Sections are applied before the content is checked, because content
-    // naming a type the bundle brings cannot pass a check until that type
-    // exists. So a refusal here may still have written files, and saying
-    // otherwise would send somebody looking in the wrong place.
-    if (result.sections) {
-      console.error(
-        `\nimport refused, but this bundle's structure was already applied: ` +
-          `${result.sections.written.length} file(s) written${
-            result.sections.schema ? `, schema ${result.sections.schema.action}` : ''
-          }.`,
-      )
-      for (const file of result.sections.written) console.error(`    ${relative(cwd, file)}`)
-      if (result.sections.replaced.length > 0)
-        console.error(
-          `  the originals are under ${relative(cwd, join(config.siteDir, ops.RUN_BACKUP_DIR))}`,
-        )
-    } else {
-      console.error(
-        `\nimport refused: ${result.check.outstanding.length} finding(s) outstanding. Nothing was written.`,
-      )
-    }
+    // Staged, then applied in one transaction: a refusal leaves nothing behind.
+    console.error(
+      `\nimport refused: ${result.check.outstanding.length || result.problems.length} finding(s) outstanding. Nothing was written.`,
+    )
     process.exit(1)
   }
 
@@ -1612,6 +1684,62 @@ async function contentExport(config: CromboloConfig): Promise<void> {
   if (counts.length === 0) process.exit(1)
 }
 
+/** `crombolo export --site`: the whole site as one file (story 104). */
+async function exportCommand(): Promise<void> {
+  if (!flags.has('--site')) {
+    console.error(
+      'export needs --site: the whole site, as one file. For a part of it, use content export.',
+    )
+    process.exit(1)
+  }
+  const config = await siteConfig()
+  const withPeople = flags.has('--with-members') || flags.has('--with-users')
+  const anonymise = flags.has('--anonymise')
+  const out = resolve(
+    flagValue('--out') ??
+      `${packageNameFor(`${config.siteName}-site`)}-${new Date().toISOString().slice(0, 10)}.tgz`,
+  )
+  const result = await ops.siteExport(config, {
+    out,
+    media: !flags.has('--no-media'),
+    drafts: flags.has('--drafts'),
+    withMembers: flags.has('--with-members'),
+    withUsers: flags.has('--with-users'),
+    anonymise,
+    passphrase:
+      withPeople && !(anonymise && !flags.has('--with-members'))
+        ? await passphraseToSeal()
+        : undefined,
+    package: { name: flagValue('--name'), version: flagValue('--package-version') },
+  })
+  const counts = Object.entries(result.counts)
+  console.log(`  wrote    ${relative(cwd, result.out) || result.out}`)
+  console.log(`  package  ${result.package.name}@${result.package.version} (private)`)
+  console.log(
+    `  content  ${counts.length > 0 ? counts.map(([kind, n]) => `${n} ${kind}`).join(', ') : 'none'}, unencrypted`,
+  )
+  const sections = Object.entries(result.sections)
+  if (sections.length > 0)
+    console.log(`  files    ${sections.map(([section, n]) => `${n} ${section}`).join(', ')}`)
+  if (result.media.omitted)
+    console.log(
+      '  media    left out (--no-media): importing it brings the media items without their files',
+    )
+  else
+    console.log(`  media    ${result.media.carried} file(s), ${describeBytes(result.media.bytes)}`)
+  for (const key of result.media.missing)
+    console.error(`  missing  ${key} is not in this environment's media store`)
+  if (result.people.members + result.people.users > 0)
+    console.log(
+      `  people   ${result.people.members} member(s), ${result.people.users} user(s), encrypted`,
+    )
+  else console.log('  people   left out: pass --with-members or --with-users to bring them')
+  if (result.anonymised !== undefined)
+    console.log(
+      `  anonymised  ${result.anonymised} email address(es) replaced; no back-office users`,
+    )
+}
+
 /**
  * `schema-as-code.md` leaves the dictionary in the database, because
  * translators work in production where `schema/` is read-only — so this is how
@@ -1804,6 +1932,117 @@ async function applyDomains(config: CromboloConfig): Promise<void> {
   }
 }
 
+/**
+ * `crombolo import <file>`: replace this site with a whole-site file (story
+ * 105). It always says first what would be replaced, and changes nothing
+ * without `--replace` or `--replace-all`.
+ */
+async function importFile(file: string): Promise<void> {
+  const config = await siteConfig()
+  const replace: ops.ReplaceMode | undefined = flags.has('--replace-all')
+    ? 'replace-all'
+    : flags.has('--replace')
+      ? 'replace'
+      : undefined
+  const dir = await ops.unpackBundle(file, config.siteDir)
+  let carriesPeople = false
+  try {
+    carriesPeople = ops.readBundle(dir, config.siteDir).set.manifest.people !== undefined
+  } catch (error) {
+    console.error(`  ${error instanceof Error ? error.message : String(error)}`)
+    process.exit(1)
+  }
+  const passphrase = carriesPeople
+    ? (process.env[PASSPHRASE_ENV] ??
+      (process.stdin.isTTY ? await readSecret('  Passphrase for its people: ') : undefined))
+    : await passphraseToOpen(dir, config)
+  const allowMissingBlobs = flags.has('--allow-missing-media')
+
+  const { check, summary } = await ops.siteReplaceCheck(config, {
+    bundle: dir,
+    passphrase,
+    replace: replace ?? 'replace',
+    allowMissingBlobs,
+  })
+  describeBundle(check.bundle)
+  const c = check.check.counts
+  console.log(`  brings   ${c.create} new, ${c.update} changed, ${c.unchanged} unchanged`)
+  const leaving = Object.entries(summary.leaving)
+  const fate = replace === 'replace-all' ? 'deleted' : 'recycled'
+  if (leaving.length > 0)
+    console.log(
+      `  ${fate.padEnd(8)} ${leaving.map(([kind, n]) => `${n} ${kind}`).join(', ')} not in the file`,
+    )
+  if (summary.filesRemoved.length > 0) {
+    console.log(
+      `  removes  ${summary.filesRemoved.length} file(s) not in the file, kept for a revert:`,
+    )
+    for (const path of summary.filesRemoved.slice(0, 20)) console.log(`    ${relative(cwd, path)}`)
+    if (summary.filesRemoved.length > 20)
+      console.log(`    … and ${summary.filesRemoved.length - 20} more`)
+  }
+  if (replace === 'replace-all' && summary.people.members + summary.people.users > 0)
+    console.log(
+      `  deletes  ${summary.people.members} member(s) and ${summary.people.users} user(s) not in the file`,
+    )
+  console.log("  keeps    domains, the secret key and this environment's settings")
+  for (const problem of check.problems) console.error(`  ${problem}`)
+
+  if (!replace) {
+    console.error(
+      '\nNothing was changed. Pass --replace to replace this site (what it loses is recycled, people kept), or --replace-all to make it exactly the file (deleted, people too).',
+    )
+    process.exit(1)
+  }
+  if (replace === 'replace-all' && !flags.has('--yes')) {
+    if (!process.stdin.isTTY) {
+      console.error(
+        '\n--replace-all deletes what the file does not have: pass --yes to confirm it.',
+      )
+      process.exit(1)
+    }
+    const answer = prompt(
+      `  This deletes for good. Type the site's name (${config.siteName}) to go on:`,
+    )
+    if (answer?.trim() !== config.siteName) {
+      console.error('  Nothing was changed.')
+      process.exit(1)
+    }
+  }
+
+  const result = await ops.contentImport(config, {
+    bundle: dir,
+    passphrase,
+    replace,
+    allowMissingBlobs,
+    label: `${replace} from ${basename(file)}`,
+    backupTaken: flags.has('--backup-taken'),
+  })
+  for (const problem of result.problems) console.error(`  ${problem}`)
+  if (result.backup.path) console.log(`  backup   ${result.backup.path}`)
+  if (!result.runId) {
+    printTransferFindings(result.check)
+    console.error('\nreplace refused. Nothing was changed.')
+    process.exit(1)
+  }
+  const counts = result.check.counts
+  console.log(`  run      ${result.runId}`)
+  console.log(
+    `  applied  ${counts.create} created, ${counts.update} updated, ${counts.unchanged} unchanged`,
+  )
+  const placed = describePlaced(result.blobs)
+  if (placed) console.log(`  media    ${placed}`)
+  if (result.sections?.schema) console.log(`  schema   ${result.sections.schema.action}`)
+  if (result.published > 0) console.log(`  published ${result.published} page(s)`)
+  for (const failure of result.publishFailures)
+    console.error(`  not published  ${failure.key}: ${failure.reason}`)
+  console.log(
+    replace === 'replace-all'
+      ? `\nDone. \`crombolo content revert ${result.runId}\` puts the files and the pages it changed back; what was deleted is in the backup.`
+      : `\nDone. \`crombolo content revert ${result.runId}\` puts it back.`,
+  )
+}
+
 /**
  * `crombolo import umbraco`: a compatibility report for an Umbraco backup, and
  * then a crombolo site written from it.
@@ -1825,7 +2064,13 @@ async function importSite(): Promise<void> {
     else if (!arg.startsWith('--')) args.push(arg)
   }
   const [kind, sub, backup] = args
+  if (kind && kind !== 'umbraco') return importFile(kind)
   if (kind !== 'umbraco' || (sub !== 'report' && sub !== 'apply')) return help()
+  // Not into --json output, which a machine reads.
+  if (!flags.has('--json'))
+    console.error(
+      '  deprecated  `crombolo import umbraco` is going away: an Umbraco extension will write a crombolo file that `crombolo import <file>` reads (story 074)',
+    )
   if (!backup) {
     console.error(`import umbraco ${sub} needs the backup: a .bacpac, or Umbraco's SQLite file.`)
     process.exit(1)
@@ -2272,6 +2517,10 @@ function help(): void {
   start [--keep-admin]        boot the site in the current directory
         [--bundle <pkg>]      apply a bundle's content first, once per bundle, then serve;
                               takes the \`content import\` flags (--publish, --under, …)
+        [--from <file>]       in an empty folder: scaffold a site, install it, import a
+                              whole-site file (crombolo export --site) and serve it; the
+                              new administrator's password is printed once
+                              [--postgres] [--name <site name>] [--no-install]
   init [--force] [--name <site name>] [--postgres] [--template <id>]
                               scaffold a site here; --template list prints the
                               starter templates, which bring schema, views and content
@@ -2298,6 +2547,12 @@ function help(): void {
   assets list                 the stylesheets and scripts this site has
   assets new <stylesheet|script> <name>
                               write an empty one in the place the backoffice edits
+  export --site [--out <file.tgz>]
+                              the whole site in one file: schema, components, styles,
+                              scripts, dictionary, every page and media item and their
+                              files. Domains and people stay behind
+                              [--no-media] [--drafts] [--with-members] [--with-users]
+                              [--anonymise] replaces every personal value as it writes
   content export --root <path|uuid> --out <dir>
                               write a private bundle package: the subtree, its
                               dependencies and what the destination must already have
@@ -2351,6 +2606,15 @@ function help(): void {
   domains clear <path|uuid|/> unbind that page, in the file and in the database
   domains apply               apply domains.toml here, as a boot does
   domains undo                put back the file the last write replaced, and apply it
+  import <file> [--replace | --replace-all]
+                              replace this site with a whole-site file. Says first what
+                              would be replaced, and changes nothing without a mode:
+                              --replace recycles content and media the file lacks and
+                              keeps this site's people; --replace-all deletes them, and
+                              people the file lacks (typed confirmation, or --yes).
+                              Domains, the secret key and settings always stay.
+                              Undone with \`content revert <run>\`
+                              [--allow-missing-media] [--backup-taken]
   import umbraco report <backup> [--site <dir>] [--media <dir>] [--out <dir>] [--json]
                               read-only: what importing an Umbraco backup would bring,
                               and what it would not — packages, Razor, custom code.
@@ -2490,6 +2754,9 @@ async function dispatch(): Promise<void> {
     case 'assets':
       await assets()
       break
+    case 'export':
+      await exportCommand()
+      break
     case 'import':
       await importSite()
       break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crombolo/cli",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "description": "The crombolo command line: scaffolding a site, schema, views, domains, content transfer and upgrades.",
   "license": "MIT",
   "author": "Crombolo",
@@ -34,11 +34,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@crombolo/auth": "0.13.2",
-    "@crombolo/core": "0.13.2",
-    "@crombolo/data": "0.13.2",
-    "@crombolo/schema": "0.13.2",
-    "@crombolo/server": "0.13.2",
-    "@crombolo/transfer": "0.13.2"
+    "@crombolo/auth": "0.14.1",
+    "@crombolo/core": "0.14.1",
+    "@crombolo/data": "0.14.1",
+    "@crombolo/schema": "0.14.1",
+    "@crombolo/server": "0.14.1",
+    "@crombolo/transfer": "0.14.1"
   }
 }

package/src/operations/commands.ts

@@ -5,7 +5,10 @@
  * a platform's own tooling — gets the same results as data. One implementation,
  * so the two can never disagree about what an import or an upgrade does.
  */
+import { existsSync } from 'node:fs'
+import { rm } from 'node:fs/promises'
 import { userInfo } from 'node:os'
+import { basename, join, resolve } from 'node:path'
 import { ROOT_ACCESS } from '@crombolo/core'
 import {
   type AuditCategory,
@@ -46,6 +49,8 @@ import {
   checkSchemaDirectory,
   createFileIntake,
   createMediaPort,
+  exportSite,
+  extractTarball,
   formTypesFor,
   installBundleContent,
   installDatabase,
@@ -53,11 +58,18 @@ import {
   mediaStoreFor,
   pendingBundleSteps,
   planBundleUpgrades,
+  type ReplaceMode,
+  type ReplaceSummary,
+  RUN_BACKUP_DIR,
   readBlobs,
   readBundle,
   recordAudit,
+  replaceSummary,
+  type SiteExportOptions,
+  type SiteExportResult,
   syncOptionsFor,
   type TransferInput,
+  useSchemaStore,
   VERSION,
 } from '@crombolo/server'
 import {
@@ -95,6 +107,7 @@ export {
   readBundle,
   replacementsNeedingPermission,
   restoreSectionFiles,
+  revertSections,
   type SectionFile,
   type SectionOptions,
   type SectionPlan,
@@ -109,16 +122,39 @@ export {
   type Resolution,
   type TransferCheck,
 } from '@crombolo/transfer'
-export type { BackupResult, WritesPaused }
+export type { BackupResult, ReplaceMode, ReplaceSummary, WritesPaused }
+
+/**
+ * A bundle file (`.tgz`, as `export --site` writes) unpacked under the site's
+ * transfer directory, where an import can read it; a directory or a package
+ * name is a bundle as it is.
+ */
+export async function unpackBundle(target: string, siteDir: string): Promise<string> {
+  if (!/\.(tgz|tar\.gz)$/i.test(target)) return target
+  const file = resolve(siteDir, target)
+  if (!existsSync(file)) throw new CommandError(`${target} does not exist.`)
+  const dir = join(
+    siteDir,
+    RUN_BACKUP_DIR,
+    'incoming',
+    basename(file).replace(/\.(tgz|tar\.gz)$/i, ''),
+  )
+  await rm(dir, { recursive: true, force: true })
+  await extractTarball(file, dir)
+  return dir
+}
 
 /** Read-only: what installing a bundle here would do. Its findings go to the Changes dashboard. */
 export async function contentCheck(
   config: CromboloConfig,
   input: TransferInput,
 ): Promise<ContentCheckResult> {
+  // Against the store's schema, not whatever local directory there is (story 106).
+  await useSchemaStore(config)
+  const bundle = await unpackBundle(input.bundle, config.siteDir)
   const { db } = await bootstrapDatabase(config)
   try {
-    return await checkBundleContent(db, config, input)
+    return await checkBundleContent(db, config, { ...input, bundle })
   } finally {
     await db.close()
   }
@@ -129,12 +165,80 @@ export async function contentImport(
   config: CromboloConfig,
   input: ContentImportInput,
 ): Promise<ContentImportResult> {
+  const bundle = await unpackBundle(input.bundle, config.siteDir)
   // Read before anything is opened or backed up, so a bundle that is not one is
   // refused before a backup is taken on its behalf.
-  readBundle(input.bundle, config.siteDir)
+  readBundle(bundle, config.siteDir)
+  await useSchemaStore(config)
+  const { db } = await bootstrapDatabase(config)
+  try {
+    return await installBundleContent(db, config, { ...input, bundle })
+  } finally {
+    await db.close()
+  }
+}
+
+export interface SiteReplaceCheck {
+  check: ContentCheckResult
+  summary: ReplaceSummary
+}
+
+/**
+ * Read-only: what `crombolo import <file>` would do (story 105) — the content
+ * check a replace runs with, and what it would take out of this site.
+ */
+export async function siteReplaceCheck(
+  config: CromboloConfig,
+  input: TransferInput & { replace: ReplaceMode },
+): Promise<SiteReplaceCheck> {
+  await useSchemaStore(config)
+  const bundle = await unpackBundle(input.bundle, config.siteDir)
+  const resolved = readBundle(bundle, config.siteDir, input.passphrase)
   const { db } = await bootstrapDatabase(config)
   try {
-    return await installBundleContent(db, config, input)
+    const check = await checkBundleContent(db, config, {
+      ...input,
+      bundle,
+      resolveAll: 'take-bundle',
+      replaceFiles: true,
+    })
+    const summary = await replaceSummary(
+      db,
+      resolved.set,
+      new Set(resolved.carried.files.keys()),
+      [
+        { section: 'schema', dir: config.schemaDir },
+        { section: 'components', dir: config.componentsDir },
+        { section: 'styles', dir: config.stylesheetsDir },
+        { section: 'scripts', dir: config.scriptsDir },
+      ],
+      input.replace,
+    )
+    return { check, summary }
+  } finally {
+    await db.close()
+  }
+}
+
+export type SiteExportInput = SiteExportOptions
+
+/**
+ * Writes the whole site to one file (story 104), streaming its media from the
+ * store. Unlike `contentExport` this writes: a site's media does not fit in a
+ * returned value.
+ */
+export async function siteExport(
+  config: CromboloConfig,
+  input: SiteExportInput,
+): Promise<SiteExportResult> {
+  await useSchemaStore(config)
+  const { db } = await bootstrapDatabase(config)
+  try {
+    return await exportSite(db, config, input)
+  } catch (error) {
+    if (error instanceof Error && !(error instanceof CommandError))
+      throw new CommandError(error.message)
+    throw error
   } finally {
     await db.close()
   }

package/templates/basic/bundle/package.json

@@ -6,7 +6,7 @@
     "content"
   ],
   "peerDependencies": {
-    "@crombolo/crombolo": ">=0.13.2"
+    "@crombolo/crombolo": ">=0.14.1"
   },
   "crombolo": {
     "id": "basic",

package/templates/demo/harbourstone/bundle/content/bundle.json

@@ -3,13 +3,13 @@
   "id": "af030aee-ba70-4bed-8a27-a3806a79100d",
   "createdAt": "2026-10-01T00:00:00.000Z",
   "createdBy": "bun run build:template",
-  "integrity": "sha256-dda870bf7e8fadb391bcadc9e75a5721cfe209a9e8aa794df2801e0b17d8e958",
+  "integrity": "sha256-d5915f80be85d8eb3aca0488721ea3b7884e6649049cd6261ced0e7f58d44c80",
   "snapshot": "published",
   "provenance": {
     "siteName": "Harbourstone Distillery",
     "schemaVersion": "1.0.0",
     "schemaRevision": "0",
-    "schemaHash": "9c729977ea20bcaca36022f92fd57b76321825b82d817f7e688bd8dc6b7ba289"
+    "schemaHash": "ac93ee497083881b983ce2f3e305e8d450a31ca1d27203223d8472fd247cae66"
   },
   "selector": {
     "roots": [
@@ -47,7 +47,8 @@
       "a562f0a2-cb6e-4ead-a1ce-4d180632419f",
       "cd681b4b-9c4e-4624-9c13-450aa6a9c135",
       "40107d59-f3e9-4592-aee8-5b03d4586cbd",
-      "3d312cc8-2937-40e1-ba14-fd781c9a862d"
+      "3d312cc8-2937-40e1-ba14-fd781c9a862d",
+      "9468d1b4-f521-48ef-b044-2ab07b461b96"
     ],
     "descendants": true,
     "asGiven": [
@@ -57,7 +58,7 @@
   "counts": {
     "media": 7,
     "element": 20,
-    "document": 8
+    "document": 9
   },
   "dependencies": {
     "carried": [
@@ -83,6 +84,7 @@
       "6d8d6398-738f-4f38-ad3c-e5d6e9a971fe",
       "7b4713f8-d917-457d-a9d8-7dd01a3617b4",
       "88ec1185-53b5-439a-a2ce-3f56603be4ff",
+      "9468d1b4-f521-48ef-b044-2ab07b461b96",
       "97469df2-107c-4010-8c14-4de88f735529",
       "a2eb439f-71d9-4ea6-89d7-c5bc72618281",
       "a562f0a2-cb6e-4ead-a1ce-4d180632419f",
@@ -124,6 +126,10 @@
           "key": "cc07b313-0843-4aa8-bbda-871c8da728c8",
           "alias": "Image"
         },
+        {
+          "key": "4308082e-5024-47fc-950d-1ee93a3e304f",
+          "alias": "searchPage"
+        },
         {
           "key": "55138391-faf2-4795-9ed6-43d581d350a4",
           "alias": "tastingNote"
@@ -138,6 +144,7 @@
         "pages/contentPage",
         "pages/expression",
         "pages/homePage",
+        "pages/searchPage",
         "pages/whiskyList"
       ],
       "languages": []

package/templates/demo/harbourstone/bundle/content/nodes/40107d59-f3e9-4592-aee8-5b03d4586cbd.json

@@ -67,6 +67,13 @@
       "editor": "Umbraco.TextBox",
       "value": "Cask strength"
     },
+    {
+      "property": "productType",
+      "culture": null,
+      "segment": null,
+      "editor": "Umbraco.TextBox",
+      "value": "Whisky"
+    },
     {
       "property": "summary",
       "culture": null,