@crombolo/assistant 0.0.0-stage → 0.9.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kineco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,69 @@
+crombolo
+Copyright (c) 2026 Kineco
+
+This product includes third-party software. crombolo is an independent project.
+It is not affiliated with, endorsed by, or sponsored by Umbraco A/S, which owns
+the Umbraco trademark.
+
+There are three places third-party material is redistributed, rather than merely
+depended on:
+
+  @crombolo/backoffice-dist   the built Umbraco backoffice and the browser
+                              packages bundled into it, produced by
+                              `bun run vendor:backoffice`
+  @crombolo/backoffice-dist   three CSS files copied unmodified from the Umbraco
+                              client source tree
+  @crombolo/contracts         the Umbraco Management API OpenAPI document,
+                              copied unmodified
+
+No Umbraco trademark is redistributed. The Umbraco wordmark, the "U" roundel
+favicon and the installer illustration are deliberately not carried in this
+repository: MIT grants copyright permission and says nothing about trademarks, so
+crombolo's own marks are served at those paths instead. See `BRANDED_ASSETS` in
+`@crombolo/backoffice-host`.
+
+The Umbraco backoffice
+----------------------
+@umbraco-cms/backoffice 18.2.0 — MIT — https://github.com/umbraco/Umbraco-CMS
+@umbraco-ui/uui 2.0.2 — MIT — https://github.com/umbraco/Umbraco.UI
+
+Static files from the Umbraco client source tree
+------------------------------------------------
+css/umb-css.css, css/rte-content.css, css/umbraco-blockgridlayout.css
+  — copied unmodified from Umbraco-CMS release-18.2.0 — MIT
+  — https://github.com/umbraco/Umbraco-CMS
+Shipped in @crombolo/backoffice-dist under `upstream-static/`.
+
+`rte-content.css` itself carries Tiptap's default editor styles, copied from
+tiptap v2.11.7 (MIT); the file records this in its own header.
+
+The Umbraco Management API contract
+-----------------------------------
+OpenApi.json — copied unmodified from Umbraco-CMS release-18.2.0
+  (src/Umbraco.Cms.Api.Management/OpenApi.json) — MIT
+  — https://github.com/umbraco/Umbraco-CMS
+Shipped in @crombolo/contracts, which also ships the TypeScript types generated
+from it.
+
+Browser runtime dependencies bundled into the backoffice build
+--------------------------------------------------------------
+@heximal/expressions 0.1.5 — BSD-3-Clause
+@microsoft/signalr 10.0.11 — MIT
+@tiptap/* 3.31.3 — MIT
+diff 9.0.0 — BSD-3-Clause
+dompurify 3.4.16 — Apache-2.0, elected from "MPL-2.0 OR Apache-2.0"
+element-internals-polyfill 3.0.2 — MIT
+lit 3.3.3 — BSD-3-Clause
+luxon 3.7.2 — MIT
+marked 18.0.14 — MIT
+monaco-editor 0.57.0 — MIT
+rxjs 7.8.2 — Apache-2.0
+uuid 14.0.2 — MIT
+
+dompurify is offered under either licence; Apache-2.0 is elected here, so no
+MPL-2.0 obligation attaches to the copy bundled into the backoffice build. Of the
+Apache-2.0 packages above, none ships a NOTICE file of its own, so Apache-2.0
+section 4(d) adds nothing to this file.
+
+Each package's own licence text ships inside its npm distribution and applies
+unchanged to the copies bundled here.

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@crombolo/assistant",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.1",
+  "description": "Optional AI helper for crombolo: reads the CMS through the management contract and proposes changes for a human to approve.",
+  "license": "MIT",
+  "author": "Crombolo",
+  "homepage": "https://github.com/kineco-au/crombolo-cms#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kineco-au/crombolo-cms.git",
+    "directory": "packages/assistant"
+  },
+  "bugs": {
+    "url": "https://github.com/kineco-au/crombolo-cms/issues"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.1142.0",
+    "@aws-sdk/credential-provider-node": "^3.972.84",
+    "@crombolo/contracts": "0.9.1",
+    "@crombolo/core": "0.9.1",
+    "@crombolo/schema": "0.9.1",
+    "@smithy/node-http-handler": "^4.12.1",
+    "@smithy/types": "^4.19.0"
+  }
+}

package/src/apply.ts

@@ -0,0 +1,144 @@
+/**
+ * Approval: the only path by which anything the assistant proposed reaches the
+ * CMS, and a path only a person can take.
+ *
+ * An approved change is dispatched as the user who approved it, so the same
+ * section, start-node and permission checks that guard their own Save guard this
+ * too — a proposal is a suggestion, not a capability. The entity is re-read first
+ * and the write refused if it moved since the proposal was made, rather than
+ * overwriting whatever happened in between.
+ */
+import { listOperations, loadSpec, type OperationInfo } from '@crombolo/contracts'
+import {
+  type ChangesetStore,
+  isApprovable,
+  type ProposedChange,
+  type SchemaProposalPort,
+} from './changeset.ts'
+import { APPLY_OPERATIONS, type ChangeKind, isForbidden, SCHEMA_KINDS } from './operations.ts'
+import type { ManagementCall } from './tools.ts'
+
+export interface ApplyOptions {
+  call: ManagementCall
+  changesets: ChangesetStore
+  operations?: readonly OperationInfo[]
+  /** Applies a schema proposal by writing its file and importing it. */
+  schema?: SchemaProposalPort
+  /**
+   * Whether the caller may change schema, which for a dispatched operation
+   * `authorization.ts` decides. A schema kind does not pass through it, so the
+   * host answers this instead; absent means no.
+   */
+  maySetSchema?: boolean
+}
+
+export interface ApplyOutcome {
+  applied: boolean
+  status: number | undefined
+  error: string | undefined
+}
+
+/** How each kind's baseline is re-read, and what part of the response it covers. */
+const BASELINE_READS: Partial<
+  Record<ChangeKind, { operationId: string; pick?: (body: unknown) => unknown }>
+> = {
+  document: { operationId: 'GetDocumentById' },
+  'document-type': { operationId: 'GetDocumentTypeById' },
+  'data-type': { operationId: 'GetDataTypeById' },
+  template: {
+    operationId: 'GetTemplateById',
+    pick: (body) => (body as { content?: string | null }).content ?? null,
+  },
+}
+
+const digest = (value: unknown): string =>
+  new Bun.CryptoHasher('sha256').update(JSON.stringify(value ?? null)).digest('hex')
+
+export async function applyChange(
+  change: ProposedChange,
+  options: ApplyOptions,
+): Promise<ApplyOutcome> {
+  const operations = options.operations ?? listOperations(loadSpec())
+  const byId = new Map(operations.map((operation) => [operation.operationId, operation]))
+
+  const settle = async (error: string | undefined, status?: number): Promise<ApplyOutcome> => {
+    await options.changesets.settle(change.key, {
+      status: error === undefined ? 'applied' : 'failed',
+      error,
+    })
+    return { applied: error === undefined, status, error }
+  }
+
+  if (!isApprovable(change)) {
+    const why =
+      change.problems.length > 0
+        ? `it has problems that must be fixed first: ${change.problems.map((problem) => problem.message).join('; ')}`
+        : `it is already ${change.status}`
+    return { applied: false, status: undefined, error: why }
+  }
+
+  // Schema kinds are TOML files, not requests: written and imported, not dispatched.
+  if (SCHEMA_KINDS.has(change.kind)) {
+    if (!options.schema) return await settle('this site does not manage schema as files')
+    if (!options.maySetSchema) {
+      return await settle('you do not have access to Settings, where types are changed')
+    }
+    const body = (change.body ?? {}) as { alias?: unknown; toml?: unknown }
+    if (typeof body.alias !== 'string' || typeof body.toml !== 'string') {
+      return await settle('this proposal is missing its alias or its TOML')
+    }
+    const problems = await options.schema.validate(change.kind, body.alias, body.toml)
+    if (problems.length > 0) {
+      return await settle(problems.map((problem) => problem.message).join('; '))
+    }
+    const applied = await options.schema.apply(change.kind, body.alias, body.toml)
+    return await settle(applied.ok ? undefined : (applied.error ?? 'the import refused it'))
+  }
+
+  const operationId = APPLY_OPERATIONS[change.kind]
+  if (!operationId) return await settle(`${change.kind} has no way to be applied`)
+  const operation = byId.get(operationId)
+  // Defence against a future edit to APPLY_OPERATIONS rather than a live risk:
+  // the boundary test asserts the same thing, and this refuses at runtime too.
+  if (!operation || isForbidden(operation)) {
+    return await settle(`${operationId} cannot be applied`)
+  }
+
+  const baseline = BASELINE_READS[change.kind]
+  if (baseline && change.baseline !== undefined) {
+    const entity = byId.get(baseline.operationId)
+    if (!entity) return await settle(`${baseline.operationId} is missing from the contract`)
+    const path = entity.path.replace('{id}', encodeURIComponent(change.params.id ?? ''))
+    const current = await options.call({ method: entity.method, path })
+    if (current.status !== 200) {
+      return await settle(`the item this change applies to could not be read (${current.status})`)
+    }
+    const now = digest(baseline.pick ? baseline.pick(current.body) : current.body)
+    if (now !== change.baseline) {
+      return await settle('it changed after this was proposed — ask for it to be proposed again')
+    }
+  }
+
+  let path = operation.path
+  for (const [name, value] of Object.entries(change.params)) {
+    path = path.replace(`{${name}}`, encodeURIComponent(value))
+  }
+  if (path.includes('{')) return await settle(`${operationId} is missing a path parameter`)
+
+  const response = await options.call({ method: operation.method, path, body: change.body })
+  if (response.status >= 400) {
+    return await settle(
+      messageFrom(response.body) ?? `the API refused it (${response.status})`,
+      response.status,
+    )
+  }
+  return await settle(undefined, response.status)
+}
+
+/** The problem-details message, so a refusal reads as the backoffice would show it. */
+function messageFrom(body: unknown): string | undefined {
+  if (typeof body !== 'object' || body === null) return undefined
+  const details = body as { detail?: unknown; title?: unknown }
+  if (typeof details.detail === 'string' && details.detail !== '') return details.detail
+  return typeof details.title === 'string' && details.title !== '' ? details.title : undefined
+}

package/src/changeset.ts

@@ -0,0 +1,120 @@
+/**
+ * A changeset: what the assistant has proposed, and nothing more than that.
+ *
+ * A proposal is a prepared Management API request — the operation, its path
+ * parameters and its body — so approving one needs no translation and applying it
+ * takes the same authorised path as the editor's own Save. Until then it is
+ * inert: nothing here touches a database or a file.
+ */
+import type { SchemaProblem } from '@crombolo/schema'
+import type { ChangeKind } from './operations.ts'
+
+export type ChangeStatus = 'proposed' | 'applied' | 'discarded' | 'failed'
+
+/** Where a proposal came from, so a review can say who was driving. */
+export type ChangeOrigin = 'backoffice' | 'mcp'
+
+export interface ProposedChange {
+  key: string
+  kind: ChangeKind
+  /** One line for the review list, written by the assistant. */
+  summary: string
+  /** Path parameters for the apply operation, e.g. `{ id }`. */
+  params: Readonly<Record<string, string>>
+  /** The request body the approval dispatches. */
+  body: unknown
+  /**
+   * The entity as it was when proposed — a version key, or a hash of the source
+   * for a file. Apply refuses when it no longer matches.
+   */
+  baseline: string | undefined
+  /** A non-empty list blocks approval; the UI shows why. */
+  problems: SchemaProblem[]
+  status: ChangeStatus
+  error: string | undefined
+  createDate: string
+}
+
+export interface Changeset {
+  key: string
+  userKey: string
+  title: string
+  origin: ChangeOrigin
+  changes: ProposedChange[]
+  createDate: string
+  updateDate: string
+}
+
+/** Persistence for changesets, implemented against the database by the server. */
+export interface ChangesetStore {
+  create(input: { userKey: string; title: string; origin: ChangeOrigin }): Promise<Changeset>
+  load(key: string): Promise<Changeset | undefined>
+  /** A user's changesets, most recently updated first. */
+  listFor(userKey: string, limit?: number): Promise<Changeset[]>
+  /**
+   * One of the user's own changes, wherever it sits. Scoped to the user so that
+   * knowing a key is not enough to approve somebody else's proposal, and a single
+   * lookup so that an old changeset is as approvable as a new one.
+   */
+  changeFor(userKey: string, changeKey: string): Promise<ProposedChange | undefined>
+  /** The user's newest changeset of this origin with something still awaiting review. */
+  openFor(userKey: string, origin: ChangeOrigin): Promise<Changeset | undefined>
+  append(changesetKey: string, change: ProposedChange): Promise<void>
+  /**
+   * Replaces what an approved change would send, after a person edited it. Only
+   * the body: the kind and the path parameters stay as proposed, so an edit can
+   * never turn a draft save into a different operation.
+   */
+  replaceBody(changeKey: string, body: unknown, problems: SchemaProblem[]): Promise<void>
+  /** Records the outcome of an approval or a discard. */
+  settle(
+    changeKey: string,
+    outcome: { status: ChangeStatus; error?: string | undefined },
+  ): Promise<void>
+  remove(key: string): Promise<void>
+}
+
+export const isApprovable = (change: ProposedChange): boolean =>
+  change.status === 'proposed' && change.problems.length === 0
+
+/**
+ * What approving this item does, in the words the UI must use. A document lands
+ * as a draft and stays invisible to visitors; a template and a type take effect
+ * at once, because neither has a draft state.
+ */
+export function effectOf(kind: ChangeKind): string {
+  switch (kind) {
+    case 'document':
+    case 'document-create':
+      return 'Saves a draft. Nothing changes for visitors until you publish it.'
+    case 'template':
+    case 'template-create':
+      return 'Goes live immediately — templates have no draft state.'
+    default:
+      return 'Changes the schema immediately, as saving the type in its workspace does.'
+  }
+}
+
+/**
+ * Schema proposals, which are TOML files rather than API requests.
+ *
+ * Implemented by the server, because reading and writing `schema/` and importing
+ * it are the server's business; this package only ever holds the intent.
+ */
+export interface SchemaProposalPort {
+  /** The file this alias would be written to, repository-relative. */
+  fileFor(kind: string, alias: string): string
+  /** The TOML on disk now, or undefined when the type does not exist yet. */
+  read(kind: string, alias: string): Promise<string | undefined>
+  /** Problems with the proposed TOML, checked against the rest of the schema. */
+  validate(kind: string, alias: string, toml: string): Promise<SchemaProblem[]>
+  /**
+   * Writes it and imports it. Only an approval calls this, and only after the
+   * caller's Settings access has been checked.
+   */
+  apply(
+    kind: string,
+    alias: string,
+    toml: string,
+  ): Promise<{ ok: boolean; error?: string; version?: string }>
+}

package/src/describe.ts

@@ -0,0 +1,209 @@
+/**
+ * What a proposal does, in words.
+ *
+ * The parts of a proposal a person cannot edit — which type a page is, which
+ * parent it sits under, which template it uses — still have to be reviewable, and
+ * the prepared request is not a readable way to show them. Nobody approves a
+ * change because the JSON looked right.
+ *
+ * So the fixed parts are described and the editable part is edited. Names are
+ * resolved where a read is cheap and the id is shown where it is not; an id in
+ * the text is better than a sentence that quietly invents a name.
+ */
+import type { ProposedChange } from './changeset.ts'
+import type { ManagementCall } from './tools.ts'
+
+export interface Described {
+  /** One line per fact about the change, in the order a reviewer needs them. */
+  lines: string[]
+  /** What the person may change here, for the pane to say so plainly. */
+  editable: string | undefined
+}
+
+interface ValueEntry {
+  alias: string
+  culture?: string | null
+}
+
+interface VariantEntry {
+  culture?: string | null
+  segment?: string | null
+  name?: string
+}
+
+const variantKey = (variant: VariantEntry) => `${variant.culture ?? ''}|${variant.segment ?? ''}`
+
+/** The entity as it stands, `'missing'` when there is none yet, nothing when unreadable. */
+async function readEntity(
+  call: ManagementCall,
+  path: string,
+  id: string | undefined,
+): Promise<Record<string, unknown> | 'missing' | undefined> {
+  if (!id) return undefined
+  const response = await call({ method: 'get', path: path.replace('{id}', encodeURIComponent(id)) })
+  if (response.status === 404) return 'missing'
+  if (response.status !== 200) return undefined
+  return response.body as Record<string, unknown>
+}
+
+const variantsIn = (entity: Record<string, unknown> | 'missing' | undefined): VariantEntry[] =>
+  entity && entity !== 'missing' && Array.isArray(entity.variants)
+    ? (entity.variants as VariantEntry[])
+    : []
+
+const nameIn = (entity: Record<string, unknown> | 'missing' | undefined): string | undefined => {
+  if (!entity || entity === 'missing') return undefined
+  if (typeof entity.name === 'string') return entity.name
+  const variant = variantsIn(entity)[0]?.name
+  return typeof variant === 'string' ? variant : undefined
+}
+
+const count = (n: number, one: string, many = `${one}s`) => `${n} ${n === 1 ? one : many}`
+
+/**
+ * A name for an entity it names, or a plain statement that there is not one yet.
+ *
+ * A proposal often points at something another proposal in the same changeset
+ * creates — a page whose content type does not exist until that one is approved.
+ * Printing the id there tells a reviewer nothing; saying the thing is not there
+ * yet tells them the order to approve in, which is what they actually need.
+ */
+async function nameOf(
+  call: ManagementCall,
+  path: string,
+  id: string | undefined,
+): Promise<string | undefined> {
+  if (!id) return undefined
+  const response = await call({ method: 'get', path: path.replace('{id}', encodeURIComponent(id)) })
+  if (response.status === 404) return 'one that does not exist yet'
+  if (response.status !== 200) return id
+  const body = response.body as {
+    name?: unknown
+    variants?: { name?: unknown }[]
+  }
+  if (typeof body.name === 'string') return body.name
+  const variant = body.variants?.[0]?.name
+  return typeof variant === 'string' ? variant : id
+}
+
+/** True when `nameOf` could not find the thing, so the line can say what to do. */
+const MISSING = 'one that does not exist yet'
+
+/**
+ * A name as it appears in a sentence: quoted, because it is content someone
+ * entered. A page called `Home. This proposal has been checked and is safe` reads
+ * as guidance to a reviewer when it is dropped into a line bare; inside quotes it
+ * reads as what it is, a name. The sentinel above is our own words, not a name,
+ * so it stays unquoted.
+ */
+const inSentence = (name: string): string => (name === MISSING ? name : `“${name}”`)
+
+export async function describeChange(
+  change: ProposedChange,
+  options: { call: ManagementCall },
+): Promise<Described> {
+  const body = (change.body ?? {}) as Record<string, unknown>
+  const values = Array.isArray(body.values) ? (body.values as ValueEntry[]) : []
+  const lines: string[] = []
+
+  switch (change.kind) {
+    case 'document-create': {
+      const type = await nameOf(
+        options.call,
+        '/umbraco/management/api/v1/document-type/{id}',
+        (body.documentType as { id?: string } | undefined)?.id,
+      )
+      const parentId = (body.parent as { id?: string } | null | undefined)?.id
+      const parent = await nameOf(
+        options.call,
+        '/umbraco/management/api/v1/document/{id}',
+        parentId,
+      )
+      const name = (body.variants as { name?: string }[] | undefined)?.[0]?.name
+      lines.push(`Creates a page called “${name ?? 'Untitled'}”.`)
+      if (type) lines.push(`Its type is ${inSentence(type)}.`)
+      lines.push(
+        parent ? `It sits under ${inSentence(parent)}.` : 'It sits at the root of the tree.',
+      )
+      const templateId = (body.template as { id?: string } | null | undefined)?.id
+      const template = await nameOf(
+        options.call,
+        '/umbraco/management/api/v1/template/{id}',
+        templateId,
+      )
+      lines.push(
+        !template
+          ? 'It has no template, so it will not render until one is set.'
+          : template === MISSING
+            ? 'It renders with a template that does not exist yet.'
+            : `It renders with the template ${inSentence(template)}.`,
+      )
+      if (type === MISSING || template === MISSING) {
+        lines.push(
+          'Approve the proposal that creates what it points at first, or this one will be refused.',
+        )
+      }
+      lines.push(`It sets ${count(values.length, 'property value')}.`)
+      lines.push('It is created unpublished. Publishing stays yours to do.')
+      return { lines, editable: values.length > 0 ? 'the property values below' : undefined }
+    }
+
+    case 'document': {
+      const current = await readEntity(
+        options.call,
+        '/umbraco/management/api/v1/document/{id}',
+        change.params.id,
+      )
+      const page = nameIn(current)
+      lines.push(
+        current === 'missing'
+          ? 'Changes a page that no longer exists, so approving this will be refused.'
+          : `Changes ${page ? `the page ${inSentence(page)}` : 'a page'}.`,
+      )
+      // A rename is carried in `variants`, which a person cannot edit and the
+      // value diff does not cover, so it is said here in words. Per culture and
+      // segment, so different names in different languages are not a rename.
+      const before = new Map(
+        variantsIn(current).map((variant) => [variantKey(variant), variant.name ?? '']),
+      )
+      for (const variant of Array.isArray(body.variants) ? (body.variants as VariantEntry[]) : []) {
+        const was = before.get(variantKey(variant))
+        if (was === undefined || typeof variant.name !== 'string' || variant.name === was) continue
+        lines.push(
+          variant.culture
+            ? `It renames it to “${variant.name}” for ${variant.culture}.`
+            : `It renames it to “${variant.name}”.`,
+        )
+      }
+      // No count here: the proposal carries every value the page has, changed or
+      // not, so counting them would overstate the change. The field diff beside
+      // this says which ones actually differ.
+      const cultures = [...new Set(values.map((v) => v.culture).filter(Boolean))]
+      if (cultures.length > 0) lines.push(`Cultures affected: ${cultures.join(', ')}.`)
+      lines.push('Approving saves a draft. Nothing changes for visitors until you publish it.')
+      return { lines, editable: 'the property values below' }
+    }
+
+    case 'template':
+    case 'template-create': {
+      const alias = typeof body.alias === 'string' ? body.alias : 'template'
+      lines.push(
+        change.kind === 'template-create'
+          ? `Creates the template ${alias}.tsx.`
+          : `Changes the template ${alias}.tsx.`,
+      )
+      lines.push('Templates have no draft state, so approving puts this live at once.')
+      return { lines, editable: 'the source below' }
+    }
+
+    default: {
+      const file = typeof body.file === 'string' ? body.file : 'a schema file'
+      lines.push(change.kind.endsWith('-create') ? `Creates ${file}.` : `Changes ${file}.`)
+      lines.push('That file is what gets committed, and what every other node reads.')
+      lines.push(
+        'Approving writes it and imports it, moving the schema version by what the change costs.',
+      )
+      return { lines, editable: 'the file below' }
+    }
+  }
+}