@crombolo/server 0.0.0-stage → 0.9.1

package/src/status.ts

@@ -0,0 +1,246 @@
+/**
+ * What an environment actually resolved to, without booting it.
+ *
+ * Everything here is already knowable — which database, which schema state,
+ * what is pending, what is outstanding — but until now only by starting a
+ * server and reading its banner, which is no use when the question is *why* it
+ * will not start.
+ *
+ * Nothing in here writes. `bootstrapDatabase` migrates and seeds, so it is
+ * deliberately not used: asking a production node how it is must never be the
+ * thing that changes it.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { ObjectTypes } from '@crombolo/core'
+import {
+  connect,
+  cromboloPlan,
+  currentSchemaState,
+  type Db,
+  INITIAL_STATE,
+  pendingMigrations,
+  readLedger,
+  readReport,
+  readState,
+  TransferRunRepository,
+} from '@crombolo/data'
+import { loadSchemaDirectory } from '@crombolo/schema'
+import { type CromboloConfig, describeDatabase, VERSION } from './config.ts'
+import { type EmailAvailability, emailAvailability, resolveEmailPort } from './email.ts'
+import { assertViewRuntime } from './view-runtime.ts'
+
+export interface SiteStatus {
+  site: {
+    name: string
+    dir: string
+    components: string
+    schema: string
+    /** Where views are snapshotted so an edit needs no restart. */
+    componentsCache: string
+  }
+  database: {
+    dialect: string
+    description: string
+    reachable: boolean
+    /** Why it could not be read, when it could not. */
+    problem?: string
+    installed: boolean
+  }
+  schema: {
+    /** The version in `schema/schema.toml`, and the revision this node deploys at. */
+    files?: string
+    revision: string
+    /** What the database is at, when it is installed. */
+    database?: { version: string; revision: string }
+    /** The database is ahead of the files: this node reads and refuses writes. */
+    compatibilityMode: boolean
+    /** The files are ahead: a sync or an upgrade is pending. */
+    pending: boolean
+  }
+  framework: { pending: string[] }
+  content: { documents: number; media: number; elements: number; lastImport?: string }
+  /**
+   * Open findings by kind. `auto` ones are reported, not counted against the
+   * site: "this page is new here" is a note, not a thing to fix.
+   */
+  findings: { blocking: number; person: number; auto: number; resolved: number }
+  versions: { crombolo: string; backoffice?: string; bun: string }
+  /**
+   * Whether e-mail can leave this site, and what is unavailable when it cannot.
+   * Not a problem — no e-mail is a valid configuration — so it is reported
+   * rather than counted against the site.
+   */
+  email: EmailAvailability
+  /** Anything that would stop this site working, in the order worth fixing. */
+  problems: string[]
+}
+
+/** `1.1.0` against `1.0.0`: which way round the two versions are. */
+function compareVersions(a: string, b: string): number {
+  const parts = (value: string) => value.split('.').map((part) => Number(part) || 0)
+  const [left, right] = [parts(a), parts(b)]
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const difference = (left[i] ?? 0) - (right[i] ?? 0)
+    if (difference !== 0) return difference
+  }
+  return 0
+}
+
+async function contentCounts(db: Db): Promise<SiteStatus['content']> {
+  const rows = await db.query<{ node_object_type: string; n: number }>(
+    `SELECT node_object_type, COUNT(*) AS n FROM node
+     WHERE trashed = ? GROUP BY node_object_type`,
+    [db.dialect.boolValue(false)],
+  )
+  const of = (objectType: string) =>
+    Number(rows.find((row) => row.node_object_type === objectType)?.n ?? 0)
+  return {
+    documents: of(ObjectTypes.Document),
+    media: of(ObjectTypes.Media),
+    elements: of(ObjectTypes.Element),
+  }
+}
+
+/** The vendored client's version, which is a fact about this deployment too. */
+function backofficeVersion(): string | undefined {
+  for (const base of [join(import.meta.dir, '..', '..'), process.cwd()]) {
+    const file = join(base, 'backoffice-dist', 'package.json')
+    if (!existsSync(file)) continue
+    try {
+      return (JSON.parse(readFileSync(file, 'utf8')) as { version?: string }).version
+    } catch {
+      return undefined
+    }
+  }
+  return undefined
+}
+
+export async function siteStatus(config: CromboloConfig): Promise<SiteStatus> {
+  const loaded = existsSync(config.schemaDir) ? loadSchemaDirectory(config.schemaDir) : undefined
+  const status: SiteStatus = {
+    site: {
+      name: config.siteName,
+      dir: config.siteDir,
+      components: config.componentsDir,
+      schema: config.schemaDir,
+      componentsCache: config.componentsCacheDir,
+    },
+    database: {
+      dialect: config.dialect,
+      description: describeDatabase(config),
+      reachable: false,
+      installed: false,
+    },
+    schema: {
+      files: loaded?.set.version,
+      revision: config.schemaRevision,
+      compatibilityMode: false,
+      pending: false,
+    },
+    framework: { pending: [] },
+    content: { documents: 0, media: 0, elements: 0 },
+    findings: { blocking: 0, person: 0, auto: 0, resolved: 0 },
+    versions: { crombolo: VERSION, backoffice: backofficeVersion(), bun: Bun.version },
+    email: emailAvailability(resolveEmailPort(config)),
+    problems: [],
+  }
+
+  // Opening a SQLite file creates it, which is a change — and the question
+  // "what is this environment?" must not be the thing that makes one.
+  // Checked here as well as at boot, so a deploy learns before it serves: a
+  // views cache the JSX runtime does not resolve from fails every render.
+  try {
+    assertViewRuntime(config.componentsCacheDir)
+  } catch (error) {
+    status.problems.push((error as Error).message.split('\n')[0] as string)
+  }
+
+  if (
+    config.dialect === 'sqlite' &&
+    config.sqliteFile !== ':memory:' &&
+    !existsSync(config.sqliteFile)
+  ) {
+    status.database.reachable = true
+    status.problems.push('there is no database yet; `crombolo start` will create one')
+    return status
+  }
+
+  let db: Db | undefined
+  try {
+    db = await connect({ file: config.sqliteFile })
+    status.database.reachable = true
+    try {
+      status.database.installed = (await readState(db)) !== INITIAL_STATE
+    } catch {
+      // Reachable, with no tables in it at all: not installed, rather than
+      // unreachable. A half-finished install looks like this.
+      status.database.installed = false
+    }
+
+    status.framework.pending = (await pendingMigrations(db, cromboloPlan)).map((m) => m.name)
+    if (!status.database.installed) {
+      status.problems.push('the database is not installed yet; `crombolo start` will install it')
+      return status
+    }
+    if (status.framework.pending.length > 0 && !config.development)
+      status.problems.push(
+        `${status.framework.pending.length} framework migration(s) pending: run \`crombolo upgrade\``,
+      )
+
+    const state = await currentSchemaState(db)
+    status.schema.database = { version: state.version, revision: state.revision }
+    if (loaded) {
+      const difference = compareVersions(loaded.set.version, state.version)
+      status.schema.compatibilityMode = difference < 0
+      status.schema.pending =
+        difference > 0 || (difference === 0 && config.schemaRevision > state.revision)
+      if (status.schema.compatibilityMode)
+        status.problems.push(
+          `the database is at ${state.version} and these files are ${loaded.set.version}: reads only, writes refused with 409`,
+        )
+      if (status.schema.pending)
+        status.problems.push(
+          'schema/ is ahead of the database: run `crombolo upgrade check` to see what it would do',
+        )
+      for (const problem of loaded.problems)
+        status.problems.push(`${problem.file}: ${problem.message}`)
+    }
+
+    status.content = await contentCounts(db)
+    const [run] = await new TransferRunRepository(db).recent(1)
+    if (run) status.content.lastImport = run.startedAt.toISOString()
+
+    const open = await readReport(db)
+    const all = await readReport(db, { includeResolved: true })
+    const of = (kind: string) => open.filter((finding) => finding.kind === kind).length
+    status.findings = {
+      blocking: of('blocking'),
+      person: of('person'),
+      auto: of('auto'),
+      resolved: all.length - open.length,
+    }
+    const wanting = status.findings.blocking + status.findings.person
+    if (wanting > 0)
+      status.problems.push(
+        `${wanting} finding(s) need somebody: \`crombolo upgrade check\` or the Changes dashboard`,
+      )
+    // Read so that a database whose ledger cannot be read is noticed here
+    // rather than at the next upgrade.
+    await readLedger(db)
+  } catch (error) {
+    status.database.problem = (error as Error).message
+    status.problems.push(
+      status.database.reachable
+        ? `the database could not be read: ${(error as Error).message}`
+        : `the database cannot be reached: ${(error as Error).message}`,
+    )
+  } finally {
+    // One exit, so a connection is never left open: on Postgres a leaked
+    // session blocks the next `DROP SCHEMA`, and the symptom is a test run
+    // that slows to a crawl rather than anything that looks like this.
+    await db?.close()
+  }
+  return status
+}

package/src/udt.ts

@@ -0,0 +1,168 @@
+/**
+ * Umbraco's dictionary export format (`.udt`): nested `<DictionaryItem Key Name>`
+ * elements, each with a `<Value LanguageCultureAlias>` per translation in CDATA.
+ * The reader understands only the XML this format uses: elements, attributes,
+ * text, CDATA, comments and the prolog.
+ */
+
+export interface UdtItem {
+  key: string
+  name: string
+  translations: Array<{ isoCode: string; translation: string }>
+  children: UdtItem[]
+}
+
+export interface XmlElement {
+  name: string
+  attributes: Record<string, string>
+  children: XmlElement[]
+  text: string
+}
+
+/** XML text content: the three characters that cannot appear raw. */
+export const escapeText = (value: string) =>
+  value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+
+const escapeAttribute = (value: string) =>
+  value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+
+const cdata = (value: string) => `<![CDATA[${value.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`
+
+function writeItem(item: UdtItem, indent: string): string {
+  const inner = [
+    ...item.translations.map(
+      (t) =>
+        `${indent}  <Value LanguageCultureAlias="${escapeAttribute(t.isoCode)}">${cdata(t.translation)}</Value>`,
+    ),
+    ...item.children.map((child) => writeItem(child, `${indent}  `)),
+  ]
+  const open = `${indent}<DictionaryItem Key="${escapeAttribute(item.key)}" Name="${escapeAttribute(item.name)}"`
+  return inner.length === 0
+    ? `${open} />`
+    : `${open}>\n${inner.join('\n')}\n${indent}</DictionaryItem>`
+}
+
+/** One item, and its descendants when they are included, as a `.udt` document. */
+export function writeUdt(item: UdtItem): string {
+  return `<?xml version="1.0" encoding="utf-8"?>\n${writeItem(item, '')}`
+}
+
+/**
+ * Several items as one `.udt` document, under the `<DictionaryItems>` wrapper
+ * `readUdt` already accepts — which is what a whole-dictionary export needs,
+ * since the tree has more than one root.
+ */
+export function writeUdtAll(items: readonly UdtItem[]): string {
+  if (items.length === 1) return writeUdt(items[0] as UdtItem)
+  const inner = items.map((item) => writeItem(item, '  ')).join('\n')
+  return `<?xml version="1.0" encoding="utf-8"?>\n<DictionaryItems>\n${inner}\n</DictionaryItems>`
+}
+
+const ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" }
+
+const decode = (value: string) =>
+  value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, entity: string) => {
+    if (entity.startsWith('#x') || entity.startsWith('#X'))
+      return String.fromCodePoint(Number.parseInt(entity.slice(2), 16))
+    if (entity.startsWith('#')) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10))
+    return ENTITIES[entity.toLowerCase()] ?? whole
+  })
+
+/** Parses a document into its root element; undefined when it is not well formed. */
+export function parseXml(source: string): XmlElement | undefined {
+  const root: XmlElement = { name: '#document', attributes: {}, children: [], text: '' }
+  const stack: XmlElement[] = [root]
+  let i = 0
+  const top = () => stack[stack.length - 1] as XmlElement
+  while (i < source.length) {
+    const lt = source.indexOf('<', i)
+    if (lt === -1) {
+      top().text += decode(source.slice(i))
+      break
+    }
+    top().text += decode(source.slice(i, lt))
+    if (source.startsWith('<![CDATA[', lt)) {
+      const end = source.indexOf(']]>', lt)
+      if (end === -1) return undefined
+      top().text += source.slice(lt + 9, end)
+      i = end + 3
+    } else if (source.startsWith('<!--', lt)) {
+      const end = source.indexOf('-->', lt)
+      if (end === -1) return undefined
+      i = end + 3
+    } else if (source.startsWith('<?', lt) || source.startsWith('<!', lt)) {
+      const end = source.indexOf('>', lt)
+      if (end === -1) return undefined
+      i = end + 1
+    } else if (source.startsWith('</', lt)) {
+      const end = source.indexOf('>', lt)
+      if (end === -1) return undefined
+      const name = source.slice(lt + 2, end).trim()
+      const closing = stack.pop()
+      if (!closing || closing.name !== name) return undefined
+      i = end + 1
+    } else {
+      const tag = /^<([A-Za-z_][\w.:-]*)((?:\s+[\w.:-]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/.exec(
+        source.slice(lt),
+      )
+      if (!tag) return undefined
+      const element: XmlElement = {
+        name: tag[1] as string,
+        attributes: {},
+        children: [],
+        text: '',
+      }
+      for (const a of (tag[2] ?? '').matchAll(/([\w.:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g))
+        element.attributes[a[1] as string] = decode(a[2] ?? a[3] ?? '')
+      top().children.push(element)
+      if (tag[3] !== '/') stack.push(element)
+      i = lt + tag[0].length
+    }
+  }
+  if (stack.length !== 1) return undefined
+  return root.children[0]
+}
+
+function readItem(element: XmlElement): UdtItem | undefined {
+  const key = element.attributes.Key
+  const name = element.attributes.Name
+  if (!key || !name) return undefined
+  const children: UdtItem[] = []
+  for (const child of element.children.filter((c) => c.name === 'DictionaryItem')) {
+    const item = readItem(child)
+    if (!item) return undefined
+    children.push(item)
+  }
+  return {
+    key,
+    name,
+    translations: element.children
+      .filter((c) => c.name === 'Value' && c.attributes.LanguageCultureAlias)
+      .map((c) => ({ isoCode: c.attributes.LanguageCultureAlias as string, translation: c.text })),
+    children,
+  }
+}
+
+/** The items a `.udt` holds: one root item, or several under `<DictionaryItems>`. */
+export function readUdt(source: string): UdtItem[] | undefined {
+  const root = parseXml(source)
+  if (!root) return undefined
+  const elements =
+    root.name === 'DictionaryItems'
+      ? root.children.filter((c) => c.name === 'DictionaryItem')
+      : root.name === 'DictionaryItem'
+        ? [root]
+        : []
+  if (elements.length === 0) return undefined
+  const items: UdtItem[] = []
+  for (const element of elements) {
+    const item = readItem(element)
+    if (!item) return undefined
+    items.push(item)
+  }
+  return items
+}

package/src/value-schemas.ts

@@ -0,0 +1,64 @@
+/**
+ * JSON Schema for what a property or a whole content type holds.
+ *
+ * Umbraco derives these from the .NET type a property editor stores, so the
+ * names it reports are .NET's. The shape is what a caller needs to validate or
+ * generate a value, which for us follows the data type's storage column.
+ */
+import type { ValueStorageTypeName } from '@crombolo/core'
+
+/** The .NET name Umbraco reports for each storage type. */
+export const VALUE_TYPE_NAMES: Record<ValueStorageTypeName, string> = {
+  Ntext: 'System.String',
+  Nvarchar: 'System.String',
+  Integer: 'System.Int32',
+  Decimal: 'System.Decimal',
+  Date: 'System.DateTime',
+}
+
+export function schemaForStorage(storage: string): Record<string, unknown> {
+  switch (storage) {
+    case 'Integer':
+      return { type: 'integer' }
+    case 'Decimal':
+      return { type: 'number' }
+    case 'Date':
+      return { type: 'string', format: 'date-time' }
+    default:
+      return { type: 'string' }
+  }
+}
+
+export const valueTypeName = (storage: string): string =>
+  VALUE_TYPE_NAMES[storage as ValueStorageTypeName] ?? 'System.String'
+
+export interface SchemaProperty {
+  alias: string
+  name: string
+  description: string | null
+  mandatory: boolean
+  storage: string
+}
+
+/** A content type as a JSON Schema object: one property per alias. */
+export function contentTypeJsonSchema(
+  type: { alias: string; name: string; description: string | null },
+  properties: readonly SchemaProperty[],
+): Record<string, unknown> {
+  const shape: Record<string, unknown> = {}
+  for (const property of properties) {
+    const schema = schemaForStorage(property.storage) as Record<string, unknown>
+    shape[property.alias] = property.description
+      ? { ...schema, title: property.name, description: property.description }
+      : { ...schema, title: property.name }
+  }
+  const required = properties.filter((p) => p.mandatory).map((p) => p.alias)
+  return {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: type.name,
+    description: type.description ?? undefined,
+    type: 'object',
+    properties: shape,
+    ...(required.length > 0 ? { required } : {}),
+  }
+}

package/src/view-runtime.ts

@@ -0,0 +1,42 @@
+/**
+ * Proving a directory can import a view, before one has to.
+ *
+ * JSX compiles to an import of `@crombolo/crombolo/jsx-runtime`, which resolves by walking
+ * up from the file that needs it. So a views directory — or a snapshot of one —
+ * outside the site's own tree cannot load at all:
+ *
+ *   Cannot find package '@crombolo/crombolo' imported from /mnt/views/homePage.tsx
+ *
+ * Checked at boot because the alternative is every render failing with a message
+ * that names the runtime rather than the configuration that moved it.
+ */
+import { mkdirSync } from 'node:fs'
+
+export const JSX_RUNTIME = '@crombolo/crombolo/jsx-runtime'
+
+export class ViewRuntimeUnreachableError extends Error {
+  constructor(
+    readonly dir: string,
+    readonly reason: string,
+  ) {
+    super(
+      `Views cannot be imported from ${dir}: '${JSX_RUNTIME}' does not resolve from there (${reason}).\n` +
+        '  JSX compiles to an import of it, resolved by walking up from the file, so the directory\n' +
+        '  has to sit inside a tree whose node_modules carries @crombolo/crombolo. Move it under the site, or\n' +
+        '  set CROMBOLO_COMPONENTS_CACHE_DIR to somewhere that is.',
+    )
+  }
+}
+
+/** Throws unless a `.tsx` placed in `dir` could resolve the JSX runtime. */
+export function assertViewRuntime(dir: string): void {
+  mkdirSync(dir, { recursive: true })
+  try {
+    Bun.resolveSync(JSX_RUNTIME, dir)
+  } catch (error) {
+    throw new ViewRuntimeUnreachableError(
+      dir,
+      error instanceof Error ? error.message : String(error),
+    )
+  }
+}

package/src/zip.ts

@@ -0,0 +1,152 @@
+/**
+ * A minimal zip writer, because a created package is a zip and nothing else
+ * here needs one (`docs/17-bundles.md`).
+ *
+ * No dependency: `node:zlib` provides `deflateRawSync` and `crc32`, which is
+ * everything the format needs. Entries are written in the order given, each
+ * stored if deflating does not make it smaller, and timestamps are fixed at the
+ * epoch the format starts from so the same selection zips to the same bytes.
+ */
+import { crc32, deflateRawSync } from 'node:zlib'
+
+export interface ZipEntry {
+  /** The path inside the archive, `/`-separated and never absolute. */
+  path: string
+  bytes: Uint8Array
+}
+
+const LOCAL_HEADER = 0x04034b50
+const CENTRAL_HEADER = 0x02014b50
+const END_OF_CENTRAL = 0x06054b50
+
+/** Deflate, or store when deflating gains nothing — as every zip writer does. */
+const STORED = 0
+const DEFLATED = 8
+
+/**
+ * 1980-01-01 00:00:00, the earliest the DOS field can express. A real time
+ * would make the bytes depend on when the download happened, and nothing reads
+ * these timestamps.
+ */
+const DOS_DATE = 0x0021
+const DOS_TIME = 0x0000
+
+/** Bit 11: the name is UTF-8, so a non-ASCII path survives the round trip. */
+const UTF8_FLAG = 0x0800
+
+class Writer {
+  #chunks: Uint8Array[] = []
+  #length = 0
+
+  get length(): number {
+    return this.#length
+  }
+
+  bytes(value: Uint8Array): void {
+    this.#chunks.push(value)
+    this.#length += value.length
+  }
+
+  u16(value: number): void {
+    const view = new Uint8Array(2)
+    new DataView(view.buffer).setUint16(0, value, true)
+    this.bytes(view)
+  }
+
+  u32(value: number): void {
+    const view = new Uint8Array(4)
+    new DataView(view.buffer).setUint32(0, value >>> 0, true)
+    this.bytes(view)
+  }
+
+  concat(): Uint8Array<ArrayBuffer> {
+    const out = new Uint8Array(this.#length)
+    let offset = 0
+    for (const chunk of this.#chunks) {
+      out.set(chunk, offset)
+      offset += chunk.length
+    }
+    return out
+  }
+}
+
+interface Compressed {
+  method: number
+  crc: number
+  deflated: Uint8Array
+  size: number
+}
+
+function compress(bytes: Uint8Array): Compressed {
+  const crc = crc32(bytes) >>> 0
+  if (bytes.length === 0) return { method: STORED, crc, deflated: bytes, size: 0 }
+  const deflated = new Uint8Array(deflateRawSync(bytes))
+  return deflated.length < bytes.length
+    ? { method: DEFLATED, crc, deflated, size: bytes.length }
+    : { method: STORED, crc, deflated: bytes, size: bytes.length }
+}
+
+/**
+ * The archive as one buffer. Package zips are a schema directory, some views
+ * and a media library's worth of images — large enough to care about, small
+ * enough that streaming would buy nothing but complexity.
+ */
+export function writeZip(entries: readonly ZipEntry[]): Uint8Array<ArrayBuffer> {
+  const encoder = new TextEncoder()
+  const body = new Writer()
+  const central = new Writer()
+
+  for (const entry of entries) {
+    const name = encoder.encode(entry.path)
+    const { method, crc, deflated, size } = compress(entry.bytes)
+    const offset = body.length
+
+    body.u32(LOCAL_HEADER)
+    body.u16(20)
+    body.u16(UTF8_FLAG)
+    body.u16(method)
+    body.u16(DOS_TIME)
+    body.u16(DOS_DATE)
+    body.u32(crc)
+    body.u32(deflated.length)
+    body.u32(size)
+    body.u16(name.length)
+    body.u16(0)
+    body.bytes(name)
+    body.bytes(deflated)
+
+    central.u32(CENTRAL_HEADER)
+    central.u16(20)
+    central.u16(20)
+    central.u16(UTF8_FLAG)
+    central.u16(method)
+    central.u16(DOS_TIME)
+    central.u16(DOS_DATE)
+    central.u32(crc)
+    central.u32(deflated.length)
+    central.u32(size)
+    central.u16(name.length)
+    central.u16(0)
+    central.u16(0)
+    central.u16(0)
+    central.u16(0)
+    // 0o100644 in the high word: a regular file, readable, as unzip expects.
+    central.u32(0o100644 << 16)
+    central.u32(offset)
+    central.bytes(name)
+  }
+
+  const out = new Writer()
+  out.bytes(body.concat())
+  const centralOffset = out.length
+  out.bytes(central.concat())
+  out.u32(END_OF_CENTRAL)
+  out.u16(0)
+  out.u16(0)
+  out.u16(entries.length)
+  out.u16(entries.length)
+  out.u32(central.length)
+  out.u32(centralOffset)
+  out.u16(0)
+  return out.concat()
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.