@happyvertical/smrt-core 0.55.10 → 0.55.12

package/AGENTS.md

@@ -27,6 +27,8 @@ and repository rules.
 | `src/registry/qualified-name-aliases.ts`, `src/migrations/qualified-name-aliases.ts` | Model moves: `previousQualifiedNames` aliases, deprecation, doctor counts, opt-in backfill (#3338) | [agents/model-moves.md](agents/model-moves.md) |
 | `src/run-once.ts` | Shared idempotency seam: insert-only claim + caller work in one transaction, replay on retry, typed in-flight/unknown-outcome answers (#3080) | [agents/run-once.md](agents/run-once.md) |
 | `src/recipe.ts`, `../scanner/src/recipes.ts` | `SmrtRecipe`: declared user-facing units (models, nav, `requires`, curation `options`) collected into manifest and knowledge `recipes` (#3590) | [agents/recipes.md](agents/recipes.md) |
+| `src/cookbook/` | Cookbook v1 document: browser-safe validate/migrate, JSON Schema (`./cookbook`, `./cookbook/v1.schema.json`; #3748) | [agents/cookbook.md](agents/cookbook.md) |
+| `src/cookbook/engine/` | Headless cookbook command engine: typed commands, idempotent retries, atomic batches, receipts, tool schemas (`./cookbook/engine`; #3753) | [agents/cookbook-engine.md](agents/cookbook-engine.md) |
 | `src/browser.ts`, `src/host.ts`, `src/host.browser.ts` | Browser entry that builds and evaluates without Node-only modules: host seam, `package.json#browser` swaps, `pnpm test:browser` (#2838) | [agents/browser-entry.md](agents/browser-entry.md) |
 
 ## Cross-module invariants

package/agents/build-knowledge.md

@@ -183,6 +183,46 @@ also dedupes `@sveltejs/kit` (`smrt:shared-runtime`): SvelteKit matches
 `redirect()`/`fail()` by class, and a linked/workspace SMRT SvelteKit entry
 would otherwise import its own copy and turn redirects into 500s.
 
+**Package models over REST (#3749).** `consumer.packages` registers a package's
+models and gives `@smrt/web` (the consumer's `collectionDefinitions`, one per
+list-capable model, endpoint `/<collection>`) their definitions, but a package
+model gets generated REST routes only when it is on the consumer's hosting
+allowlist (`smrtConsumer({ svelteKit: { objects } })`, #2850: an HTTP exposure
+boundary, each model's own `api` config still applies, so `api: false` and
+empty-include models stay closed, tenancy comes with the generated route). The
+preset fills that allowlist: with `smrt.cookbook.json` present it is the models
+of the cookbook's recipes plus `features`, minus models the cookbook `exposure`
+turns off for `api` or a recipe's `options[model].exposure.api === false`
+(`vite-preset/cookbook-exposure.ts`; recipe `{ exclude }` narrowing is not
+applied by the build yet). `smrt({ expose })` replaces the derived list. No
+cookbook and no `expose` keeps `svelteKit: true` (nothing hosted). The producer's
+`@happyvertical/smrt-virt-web` still covers only the app's own models; read
+package models from `@smrt/web`. `smrt({ objectsDir })` is passed to the hosting
+contribution too: the producer and consumer share one `routesDir`, and the
+generator refuses it when their settings differ.
+
+**STI siblings (#3749).** Package STI subclasses share their base's table, and
+the manifest gives them the base's `collection` unless they declare one
+(`consumer-plugin/hosted-sti-collections.ts`). Two hosted siblings would both
+claim `/<base collection>`, so each hosted subclass that inherits its
+collection gets its class-derived one (`Order` -> `orders`,
+`defaultCollectionName` in the scanner), in every manifest view the consumer
+derives: routes, `@smrt/web`, the generated client and registration. This is the
+convention the framework already has for an independent route collection
+(`@smrt({ collection })`), applied by default for hosted subclasses; an explicit
+collection wins. The route therefore reads through the subclass's own
+collection (rows scoped to its `_meta_type`) and the definition for that model
+advertises that route (`objectRef` = the model, `endpoint` = `/orders`). A hosted
+base keeps the shared name and the base-collection semantics (every row of the
+table, any subtype). A subclass left off the allowlist keeps the shared
+collection and folds into the base's definition, as before. A collection class
+that inherits another's item type (`MaterialCollection extends
+ProductCollection`) resolves to the same item and collection, so only one of
+them is hosted (the class named for the item, else the first). Subclasses that
+declare no `api` config get the omitted-config default (full CRUD), not the
+base's `include`; narrow them on the subclass if the base is meant to restrict
+them.
+
 ```typescript
 // vite.config.ts — required for @smrt() decorators (Vite 8+, oxc transform)
 export default defineConfig({

package/agents/cookbook-engine.md

@@ -0,0 +1,102 @@
+# Cookbook command engine (#3753)
+
+`@happyvertical/smrt-core/cookbook/engine` (`src/cookbook/engine/`) is the one
+place the rules for changing a [cookbook](cookbook.md) live. A planner UI, a
+local Kitchen MCP server, the CLI and a website all call it; each is an adapter.
+It imports only relative modules and `@happyvertical/smrt-types` types, so it
+runs in Node and in a browser. No SvelteKit, storage, singleton or inference.
+
+It lives in `smrt-core` because the contract and validator (`./cookbook`) do and
+the package DAG forbids a back edge: types -> core. A separate package would add
+a node for pure functions with no other dependency.
+
+## API
+
+```ts
+import { createCookbookEngine } from '@happyvertical/smrt-core/cookbook/engine';
+const engine = createCookbookEngine({ catalog, cookbook?, state? });
+engine.run({ id?, name, input, expectedRevision? }) // CommandResult, never throws
+engine.batch({ id?, commands, expectedRevision? })  // BatchResult, atomic
+engine.snapshot() / .cookbook() / .state() / .subscribe(fn)
+engine.tools / engine.batchTool                      // JSON Schema tool definitions
+```
+
+- **Catalog is data** (`EngineCatalog`): `recipes` (manifest `RecipeDefinition`
+  fits), `models` (`id, name, packageId, exposed?, fields?`), optional
+  `cookbooks` (a library), `themePresets`, `currencies`, `settingTargets`.
+  Nothing is bundled. Build it from published manifests or `smrt-knowledge.json`.
+- **Commands** (20, `COOKBOOK_COMMANDS_VERSION = 1`): `apply_cookbook` (select),
+  `import_cookbook`, `add_cookbook`, `remove_cookbook`, `add_recipes`,
+  `remove_recipes`, `add_features`, `remove_features`, `set_settings`,
+  `set_policy`, `set_theme`, `reset_theme`, `set_name`, `rename_section`,
+  `rename_item`, `hide`, `show`, `validate`, `export_cookbook`, `undo`. Navigation
+  and focus are not commands: they are an adapter concern.
+- **Errors** are typed (`CommandError`: `code`, `message`, `path?`, `details?`):
+  `unknown_command`, `invalid_input`, `not_found`, `confirmation_required`,
+  `conflict`, `id_reuse`, `batch_failed`, `failed`.
+- **Result** carries the `receipt` (`name, id?, summary, changed, revisionBefore,
+  revisionAfter, undoId?, changes?, warnings?`), the compact `snapshot` and
+  optional `data` (`validate`, `export_cookbook`).
+
+## Execution contract
+
+- **Revisions** count applied changes (a no-op does not move it), so equal
+  histories give equal revisions. `expectedRevision` that is not current fails
+  `conflict` with `details.{expectedRevision,currentRevision}`: an older model
+  action cannot overwrite a newer manual edit. Send it on every model action.
+- **Command ids**: a repeated `id` with the same command returns the first
+  result with `replayed: true` and applies nothing (failures replay too: take a
+  new id after re-reading). The same id with a different command is `id_reuse`.
+  The journal keeps `maxJournal` (500) ids and is part of `state()`.
+- **Atomic batches** run on a working copy; one failure leaves the state
+  byte-identical and returns `batch_failed` naming `details.index`. A batch that
+  changes n times advances the revision by n, as n runs would, and has one undo.
+  `undo` and per-command ids/revisions are not allowed inside a batch.
+- **Undo** restores the document from before the change; it is a `conflict`
+  while the plan differs from what that change left, unless `force`.
+- **Recovery**: `state()` is plain JSON (revision, applied library id, document,
+  journal); `createCookbookEngine({ catalog, state })` resumes it, retries
+  included. Undo entries are not persisted.
+- **Canonical document**: ids sorted, policies sorted, empty sections absent,
+  key order fixed, so two engines export identical text. Recipe/feature ids the
+  catalog lacks stay in the document and show as `snapshot.unavailable`.
+
+## Deliberately not here
+
+Package or starter version pinning (waits on #3604/#3754). Deep overview-widget
+and nav-id checks (smrt-svelte owns them; `import_cookbook` carries `overviews`
+and `layout` through unjudged, `validate` only flags layout ids the menu lacks).
+Typed diagnostics from `validateCookbook` itself (#3754): `validate` wraps its
+strings as `invalid_document` until it returns them.
+
+## Becoming an adapter: what smrt-planner changes (after the smrt release)
+
+Parity to hold: the planner's `tests/headless-planner.test.ts` scenario is
+ported in `__tests__/engine.test.ts` (`SCRIPT`) over a data catalog.
+
+1. Depend on the released `@happyvertical/smrt-core`; build `EngineCatalog` from
+   its catalog data (`recipes.json`/`catalog.json` -> `recipes`, `models`,
+   `cookbooks`: the library wrapper keeps id/icon/keywords planner-side).
+2. Delete `commands/execute.ts`, `commands/runner.ts`, `commands/snapshot.ts`,
+   `commands/schemas.ts` (keep `checkSchema` only if still used), `recipes/
+   plan-data.ts`, `recipes/resolve.ts`, `settings/app-settings.ts` rules,
+   `assistant/change.ts` apply* helpers, `cookbook/assemble.ts` and the
+   `createPlainHost`. `createHeadlessPlanner` becomes `createCookbookEngine`
+   behind the same `run/snapshot/subscribe/cookbook` names.
+3. The browser controller keeps: `focus` and the planner tab/section cells
+   (snapshot `focus` is added by the adapter), reactive wrapping of
+   `engine.subscribe`, `onReplaced` (regenerate sample data after
+   `apply_cookbook`), and the `cookbookStore` <-> `engine.state()` sync
+   (`engine.cookbook()` to persist; rebuild with `cookbook`/`state` on load).
+4. Command differences to absorb: `apply_cookbook`/`import_cookbook` report
+   `changed` by content; `rename_*`/`hide`/`show` need the catalog `models`
+   `packageId` for item ids; undo is whole-document (the old per-slice undo goes);
+   `unsupported` is gone (the engine always has every slice); new `set_name`,
+   `validate`; receipts gain `revisionBefore/After`; `expectedRevision` moves
+   into the command (the option form still works).
+5. Overview customisation stays a planner/smrt-svelte concern; hold `overviews`
+   in the document via `import_cookbook` and write them with a planner-side
+   command until an engine command is agreed.
+6. MCP/Kitchen (#3752, done): `smrt kitchen mcp` holds one engine per plan id and
+   serves `engine.batchTool`'s schema as `run_commands`; the plan reaches disk
+   as `smrt.cookbook.json` through `cookbook apply` (`cli/agents/kitchen.md`).

package/agents/cookbook.md

@@ -0,0 +1,74 @@
+# Cookbook v1 contract (#3747, #3748)
+
+A cookbook is the portable JSON document that says what an app is made of.
+Defined once here so the CLI (`smrt cookbook validate|apply`) and the cookbook
+app shell read the same thing.
+
+| Piece | Where |
+|---|---|
+| Types (type-only) | `@happyvertical/smrt-types`: `Cookbook`, `CookbookPolicyRow`, `CookbookLayout`, `CookbookTheme`, `CookbookOverviewOverride`, `CookbookExposureSurface` |
+| Parse / validate / migrate (browser-safe) | `@happyvertical/smrt-core/cookbook`: `validateCookbook(doc, { recipes? })`, `parseCookbookText`, `COOKBOOK_SCHEMA_URL`, `COOKBOOK_LEGACY_SCHEMA_URL`, `COOKBOOK_VERSION` |
+| JSON Schema | `@happyvertical/smrt-core/cookbook/v1.schema.json` (`$id` is the `$schema` URL; s-m-r-t.dev hosts it later) |
+| App shell | `@happyvertical/smrt-svelte/cookbook` renders a cookbook; `loadCookbookApp` in `/cookbook/server` loads and validates it ([cookbook-shell.md](../../smrt-svelte/agents/cookbook-shell.md)) |
+| Fixtures | `src/cookbook/__fixtures__/` (the planner's bakery, mechanic, welder, yoga-studio documents) |
+
+Fields: `$schema`, `version: 1`, optional `name`/`description`, `recipes`,
+`features` (absent reads as `[]`), `policies` (app-scope smrt-fields rows),
+`exposure`, `layout` (smrt-svelte `ShellLayout`), `theme`, `overviews`
+(smrt-svelte `OverviewOverride` per overview id). Sample data is not part of
+the document; the planner's library wrapper (id, icon, keywords, settings) is
+planner-side.
+
+## Rules
+
+- Versioning: add optional fields within `version: 1`; readers keep and ignore
+  unknown keys (`additionalProperties: true`). A breaking change is `version: 2`.
+- Layout and overview values are typed structurally so smrt-types and core never
+  depend on smrt-svelte; smrt-svelte owns deep validation (widgets against page
+  definitions, nav ids). `CookbookLayout`/`CookbookOverviewOverride` are
+  identical to the smrt-svelte types; a typechecked assertion in smrt-svelte
+  (`cookbook/__tests__/contract-types.ts`) fails when either side adds a field.
+- Legacy `.../blueprint/v1.json` is accepted on read and rewritten; never written.
+- Recipe existence, `requires`/`requiresAny` and setting targets need manifests:
+  `validateCookbook(doc, { recipes })` checks ids when a catalog is passed;
+  the rest is the CLI's job.
+- Keep the JSON Schema and `validate.ts` in step; the test validates the same
+  fixtures against both.
+
+## Applying a cookbook
+
+`smrt cookbook validate <file|url>` and `smrt cookbook apply <file|url> [dir]`
+(`packages/cli/agents/cookbook-apply.md`) are the consumers. Apply writes
+`smrt.cookbook.json` at the project root, plus the packages the recipes,
+features and policies need, into `package.json`. The file is the cookbook
+verbatim (legacy `$schema` rewritten); apps read it, apply does not interpret it.
+`policies` is required by the validator (use `[]`). The cookbook carries no package
+versions, so apply uses the project's smrt line.
+
+## Hosting package models
+
+An app that applies a cookbook lists the recipes' packages in `consumer.packages`
+and nothing else: the `smrt()` Vite preset derives the REST allowlist from the
+cookbook, so the Orders of a `commerce.sales` recipe get `/api/orders` routes and
+an `@smrt/web` definition (see [build-knowledge.md](build-knowledge.md), "Package
+models over REST"). `exposure` listing `api` for a model withdraws its route. Models that share an
+STI table (the bakery's `Order`, `WholesaleOrder`, `PurchaseOrder` and
+`ProductionOrder`; `Product` and `Material`) each get their own route and
+definition, at `/<class collection>` (`/orders`, `/productionorders`), listing
+only their own rows; the build-knowledge section explains why.
+
+Permissions do not follow the route. The permission catalog grants one namespace
+per STI table, the base's (`contracts.create`; there is no `orders.create`), so a
+hosted subclass moved to its own route collection keeps authorizing against the
+base's slugs: the hosting rewrite records the original collection as
+`permissionCollection`, which the generated route guard and `sync/apply` read
+before the (rewritten) route collection. It matches the fail-closed `api`
+inheritance and the CLI/MCP operation guards, which already derive the base's
+slug. No role is widened: a caller needs exactly the grants the base requires.
+Reads need no operation slug. A subclass that declares its own `collection` has
+its own namespace and is untouched.
+
+## Editing a cookbook
+
+The command engine (`@happyvertical/smrt-core/cookbook/engine`) is the one place
+that changes a cookbook: see [cookbook-engine.md](cookbook-engine.md).

package/dist/consumer-plugin/artifact-publication.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
 //#region src/consumer-plugin/artifact-publication.ts
 /**
 * Stage and publish a related artifact set with synchronous-failure recovery.
@@ -13,7 +13,7 @@ import * as fs from "node:fs";
 * There is no portable multi-file filesystem transaction: a process crash or a
 * concurrent reader between individual renames can still observe a mixed set.
 */
-function publishArtifactFiles(files, filesystem = fs) {
+function publishArtifactFiles(files, filesystem = fs$1) {
 	const unique = `${process.pid}-${Date.now()}`;
 	const staged = [];
 	const backed = [];
@@ -76,7 +76,7 @@ function publishArtifactFiles(files, filesystem = fs) {
 	}
 }
 /** Atomically replace one artifact without ever removing its reader-visible path. */
-function publishAtomicArtifact(file, filesystem = fs) {
+function publishAtomicArtifact(file, filesystem = fs$1) {
 	const stagedPath = `${file.path}.smrt-${randomUUID()}.tmp`;
 	const stats = filesystem.existsSync(file.path) ? filesystem.statSync(file.path) : void 0;
 	if (stats && !stats.isFile()) throw new Error(`Artifact target is not a file: ${file.path}`);

package/dist/consumer-plugin/artifact-publication.js.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-publication.js","names":[],"sources":["../../src/consumer-plugin/artifact-publication.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport * as fs from 'node:fs';\n\nexport interface ArtifactFile {\n  path: string;\n  content: string;\n}\n\nexport interface ArtifactFilesystem {\n  existsSync: typeof fs.existsSync;\n  renameSync: typeof fs.renameSync;\n  statSync: typeof fs.statSync;\n  unlinkSync: typeof fs.unlinkSync;\n  writeFileSync: typeof fs.writeFileSync;\n  chmodSync: typeof fs.chmodSync;\n}\n\ninterface StagedArtifact {\n  path: string;\n  stagedPath: string;\n  backupPath?: string;\n}\n\n/**\n * Stage and publish a related artifact set with synchronous-failure recovery.\n *\n * Every existing target is first renamed to an adjacent backup, preserving its\n * mode, before a staged replacement is renamed into place. If a later rename\n * fails, rollback restores backups using rename only; it never truncates an\n * old target by rewriting it. A rollback failure retains its backup for manual\n * recovery and is included with the original publication failure.\n *\n * There is no portable multi-file filesystem transaction: a process crash or a\n * concurrent reader between individual renames can still observe a mixed set.\n */\nexport function publishArtifactFiles(\n  files: ArtifactFile[],\n  filesystem: ArtifactFilesystem = fs,\n): void {\n  const unique = `${process.pid}-${Date.now()}`;\n  const staged: StagedArtifact[] = [];\n  const backed: StagedArtifact[] = [];\n  const published: StagedArtifact[] = [];\n  let retainBackups = false;\n\n  try {\n    for (const [index, file] of files.entries()) {\n      const exists = filesystem.existsSync(file.path);\n      const stats = exists ? filesystem.statSync(file.path) : undefined;\n      if (stats && !stats.isFile()) {\n        throw new Error(`Artifact target is not a file: ${file.path}`);\n      }\n      const mode = stats ? stats.mode & 0o777 : undefined;\n      const stagedFile = {\n        path: file.path,\n        stagedPath: `${file.path}.smrt-${unique}-${index}.tmp`,\n        backupPath: exists\n          ? `${file.path}.smrt-${unique}-${index}.bak`\n          : undefined,\n      };\n      // Register before the write: a failed write can still leave a partial\n      // temporary file, which the finally cleanup must see.\n      staged.push(stagedFile);\n      filesystem.writeFileSync(stagedFile.stagedPath, file.content, 'utf-8');\n      if (mode !== undefined) filesystem.chmodSync(stagedFile.stagedPath, mode);\n    }\n    for (const file of staged) {\n      if (!file.backupPath) continue;\n      filesystem.renameSync(file.path, file.backupPath);\n      backed.push(file);\n    }\n    for (const file of staged) {\n      filesystem.renameSync(file.stagedPath, file.path);\n      published.push(file);\n    }\n  } catch (publicationError) {\n    const rollbackErrors: unknown[] = [];\n    for (const file of backed.reverse()) {\n      try {\n        if (!file.backupPath) {\n          throw new Error(`Missing artifact backup: ${file.path}`);\n        }\n        // Replacing a published staged file is safe: its authoritative prior\n        // contents are held by backupPath until this rename succeeds.\n        filesystem.renameSync(file.backupPath, file.path);\n      } catch (rollbackError) {\n        rollbackErrors.push(rollbackError);\n      }\n    }\n    for (const file of published) {\n      if (file.backupPath) continue;\n      try {\n        if (filesystem.existsSync(file.path)) filesystem.unlinkSync(file.path);\n      } catch (rollbackError) {\n        rollbackErrors.push(rollbackError);\n      }\n    }\n    if (rollbackErrors.length > 0) {\n      retainBackups = true;\n      throw new AggregateError(\n        [publicationError, ...rollbackErrors],\n        'Artifact publication failed and rollback retained recovery backups',\n      );\n    }\n    throw publicationError;\n  } finally {\n    for (const file of staged) {\n      try {\n        if (filesystem.existsSync(file.stagedPath))\n          filesystem.unlinkSync(file.stagedPath);\n      } catch {\n        // A staging file is not an authoritative artifact.\n      }\n      if (!retainBackups) {\n        try {\n          if (file.backupPath && filesystem.existsSync(file.backupPath)) {\n            filesystem.unlinkSync(file.backupPath);\n          }\n        } catch {\n          // A failed cleanup leaves a recoverable backup behind.\n        }\n      }\n    }\n  }\n}\n\n/** Atomically replace one artifact without ever removing its reader-visible path. */\nexport function publishAtomicArtifact(\n  file: ArtifactFile,\n  filesystem: ArtifactFilesystem = fs,\n): void {\n  const stagedPath = `${file.path}.smrt-${randomUUID()}.tmp`;\n  const exists = filesystem.existsSync(file.path);\n  const stats = exists ? filesystem.statSync(file.path) : undefined;\n  if (stats && !stats.isFile()) {\n    throw new Error(`Artifact target is not a file: ${file.path}`);\n  }\n  try {\n    filesystem.writeFileSync(stagedPath, file.content, 'utf-8');\n    if (stats) filesystem.chmodSync(stagedPath, stats.mode & 0o777);\n    // POSIX rename replaces the destination atomically: readers see either\n    // the old complete file or the new complete file, never no path/bytes.\n    filesystem.renameSync(stagedPath, file.path);\n  } finally {\n    if (filesystem.existsSync(stagedPath)) filesystem.unlinkSync(stagedPath);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"artifact-publication.js","names":[],"sources":["../../src/consumer-plugin/artifact-publication.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport * as fs from 'node:fs';\n\nexport interface ArtifactFile {\n  path: string;\n  content: string;\n}\n\nexport interface ArtifactFilesystem {\n  existsSync: typeof fs.existsSync;\n  renameSync: typeof fs.renameSync;\n  statSync: typeof fs.statSync;\n  unlinkSync: typeof fs.unlinkSync;\n  writeFileSync: typeof fs.writeFileSync;\n  chmodSync: typeof fs.chmodSync;\n}\n\ninterface StagedArtifact {\n  path: string;\n  stagedPath: string;\n  backupPath?: string;\n}\n\n/**\n * Stage and publish a related artifact set with synchronous-failure recovery.\n *\n * Every existing target is first renamed to an adjacent backup, preserving its\n * mode, before a staged replacement is renamed into place. If a later rename\n * fails, rollback restores backups using rename only; it never truncates an\n * old target by rewriting it. A rollback failure retains its backup for manual\n * recovery and is included with the original publication failure.\n *\n * There is no portable multi-file filesystem transaction: a process crash or a\n * concurrent reader between individual renames can still observe a mixed set.\n */\nexport function publishArtifactFiles(\n  files: ArtifactFile[],\n  filesystem: ArtifactFilesystem = fs,\n): void {\n  const unique = `${process.pid}-${Date.now()}`;\n  const staged: StagedArtifact[] = [];\n  const backed: StagedArtifact[] = [];\n  const published: StagedArtifact[] = [];\n  let retainBackups = false;\n\n  try {\n    for (const [index, file] of files.entries()) {\n      const exists = filesystem.existsSync(file.path);\n      const stats = exists ? filesystem.statSync(file.path) : undefined;\n      if (stats && !stats.isFile()) {\n        throw new Error(`Artifact target is not a file: ${file.path}`);\n      }\n      const mode = stats ? stats.mode & 0o777 : undefined;\n      const stagedFile = {\n        path: file.path,\n        stagedPath: `${file.path}.smrt-${unique}-${index}.tmp`,\n        backupPath: exists\n          ? `${file.path}.smrt-${unique}-${index}.bak`\n          : undefined,\n      };\n      // Register before the write: a failed write can still leave a partial\n      // temporary file, which the finally cleanup must see.\n      staged.push(stagedFile);\n      filesystem.writeFileSync(stagedFile.stagedPath, file.content, 'utf-8');\n      if (mode !== undefined) filesystem.chmodSync(stagedFile.stagedPath, mode);\n    }\n    for (const file of staged) {\n      if (!file.backupPath) continue;\n      filesystem.renameSync(file.path, file.backupPath);\n      backed.push(file);\n    }\n    for (const file of staged) {\n      filesystem.renameSync(file.stagedPath, file.path);\n      published.push(file);\n    }\n  } catch (publicationError) {\n    const rollbackErrors: unknown[] = [];\n    for (const file of backed.reverse()) {\n      try {\n        if (!file.backupPath) {\n          throw new Error(`Missing artifact backup: ${file.path}`);\n        }\n        // Replacing a published staged file is safe: its authoritative prior\n        // contents are held by backupPath until this rename succeeds.\n        filesystem.renameSync(file.backupPath, file.path);\n      } catch (rollbackError) {\n        rollbackErrors.push(rollbackError);\n      }\n    }\n    for (const file of published) {\n      if (file.backupPath) continue;\n      try {\n        if (filesystem.existsSync(file.path)) filesystem.unlinkSync(file.path);\n      } catch (rollbackError) {\n        rollbackErrors.push(rollbackError);\n      }\n    }\n    if (rollbackErrors.length > 0) {\n      retainBackups = true;\n      throw new AggregateError(\n        [publicationError, ...rollbackErrors],\n        'Artifact publication failed and rollback retained recovery backups',\n      );\n    }\n    throw publicationError;\n  } finally {\n    for (const file of staged) {\n      try {\n        if (filesystem.existsSync(file.stagedPath))\n          filesystem.unlinkSync(file.stagedPath);\n      } catch {\n        // A staging file is not an authoritative artifact.\n      }\n      if (!retainBackups) {\n        try {\n          if (file.backupPath && filesystem.existsSync(file.backupPath)) {\n            filesystem.unlinkSync(file.backupPath);\n          }\n        } catch {\n          // A failed cleanup leaves a recoverable backup behind.\n        }\n      }\n    }\n  }\n}\n\n/** Atomically replace one artifact without ever removing its reader-visible path. */\nexport function publishAtomicArtifact(\n  file: ArtifactFile,\n  filesystem: ArtifactFilesystem = fs,\n): void {\n  const stagedPath = `${file.path}.smrt-${randomUUID()}.tmp`;\n  const exists = filesystem.existsSync(file.path);\n  const stats = exists ? filesystem.statSync(file.path) : undefined;\n  if (stats && !stats.isFile()) {\n    throw new Error(`Artifact target is not a file: ${file.path}`);\n  }\n  try {\n    filesystem.writeFileSync(stagedPath, file.content, 'utf-8');\n    if (stats) filesystem.chmodSync(stagedPath, stats.mode & 0o777);\n    // POSIX rename replaces the destination atomically: readers see either\n    // the old complete file or the new complete file, never no path/bytes.\n    filesystem.renameSync(stagedPath, file.path);\n  } finally {\n    if (filesystem.existsSync(stagedPath)) filesystem.unlinkSync(stagedPath);\n  }\n}\n"],"mappings":"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"}

package/dist/consumer-plugin/hosted-sti-collections.d.ts

@@ -0,0 +1,10 @@
+import type { SmartObjectDefinition } from '../scanner/types.js';
+/**
+ * @param manifest - The aggregated manifest of every consumed package.
+ * @param hosted - Provider-qualified refs the consumer hosts.
+ * @param refOf - The qualified ref of a manifest entry.
+ * @returns The manifest with each hosted, collection-inheriting STI subclass
+ *   moved to its own collection; `manifest` itself when none needs it.
+ */
+export declare function separateHostedStiCollections<M extends object>(manifest: M, hosted: readonly string[], refOf: (key: string, def: SmartObjectDefinition) => string | undefined): M;
+//# sourceMappingURL=hosted-sti-collections.d.ts.map

package/dist/consumer-plugin/hosted-sti-collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-sti-collections.d.ts","sourceRoot":"","sources":["../../src/consumer-plugin/hosted-sti-collections.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,qBAAqB,CAAC;AAyC7B;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,MAAM,EAC3D,QAAQ,EAAE,CAAC,EACX,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,qBAAqB,KAAK,MAAM,GAAG,SAAS,GACrE,CAAC,CAqDH"}

package/dist/consumer-plugin/hosted-sti-collections.js

@@ -0,0 +1,96 @@
+import { findManifestObjectByName, isCollectionManifestClass, isStiChildModel, resolveCollectionItemObject } from "../vite-plugin/web-collections.js";
+import { defaultCollectionName } from "@happyvertical/smrt-scanner";
+//#region src/consumer-plugin/hosted-sti-collections.ts
+/**
+* Own route collections for hosted STI subclasses (#3749).
+*
+* An STI subclass shares its base's table, and the manifest generator also
+* gives it the base's `collection` unless it declares one
+* (`@smrt({ collection })`, "collection controls routes/permissions
+* independently of shared storage"). Hosting `Order` and `ProductionOrder`
+* beside each other would therefore claim `/contracts` twice, and one handler
+* would silently shadow the other.
+*
+* A hosted subclass that has not declared a collection gets its class-derived
+* one (`orders`), the name it would have had as a plain model. Its generated
+* route then lists and reads through its own collection, which already scopes
+* every read to the subclass `_meta_type`; permissions do not move with it (the
+* catalog grants the STI base's `contracts.*` slugs only, #3770), so the moved
+* definition records the original collection as `permissionCollection`; the base keeps the shared name and
+* the base-collection semantics (every row of the table). The same rewritten
+* manifest feeds the `@smrt/web` definitions and the generated client, so each
+* hosted class advertises exactly the endpoint its route serves.
+*/
+/**
+* The `api` config of the nearest STI ancestor that declares one. An omitted
+* `api` means full CRUD, so a hosted subclass that says nothing would expose
+* `DELETE /orders/:id` even though its base (`Contract`) allows only
+* list/get/create/update. Hosting fails closed: the subclass inherits the base's
+* exposure unless it declares its own (hosting path only; the framework-wide
+* default is unchanged).
+*/
+function inheritedApi(manifest, obj) {
+	const seen = /* @__PURE__ */ new Set();
+	let child = obj;
+	let parentName = child.extendsQualified || child.extends;
+	while (parentName && !seen.has(parentName)) {
+		seen.add(parentName);
+		const parent = findManifestObjectByName(manifest, parentName, child);
+		if (!parent) return void 0;
+		if (!(parent.collection === obj.collection || parent.decoratorConfig?.tableStrategy === "sti")) return void 0;
+		const api = parent.decoratorConfig?.api;
+		if (api !== void 0) return api;
+		child = parent;
+		parentName = parent.extendsQualified || parent.extends;
+	}
+}
+/**
+* @param manifest - The aggregated manifest of every consumed package.
+* @param hosted - Provider-qualified refs the consumer hosts.
+* @param refOf - The qualified ref of a manifest entry.
+* @returns The manifest with each hosted, collection-inheriting STI subclass
+*   moved to its own collection; `manifest` itself when none needs it.
+*/
+function separateHostedStiCollections(manifest, hosted, refOf) {
+	const source = manifest;
+	const wanted = new Set(hosted);
+	let objects;
+	const moved = /* @__PURE__ */ new Map();
+	for (const [key, def] of Object.entries(source.objects)) {
+		const ref = refOf(key, def);
+		if (!ref || !wanted.has(ref)) continue;
+		const collection = !def.decoratorConfig?.collection && isStiChildModel(source, def) ? defaultCollectionName(def.className) : def.collection;
+		const api = def.decoratorConfig?.api === void 0 ? inheritedApi(source, def) : void 0;
+		if (collection === def.collection && api === void 0) continue;
+		if (collection !== def.collection) moved.set(def, collection);
+		objects ??= { ...source.objects };
+		objects[key] = {
+			...def,
+			collection,
+			...collection === def.collection ? {} : { permissionCollection: def.collection },
+			...api === void 0 ? {} : { decoratorConfig: {
+				...def.decoratorConfig,
+				api
+			} }
+		};
+	}
+	if (!objects) return manifest;
+	for (const [key, def] of Object.entries(source.objects)) {
+		if (!isCollectionManifestClass(source, def)) continue;
+		const item = resolveCollectionItemObject(source, def);
+		const collection = item ? moved.get(item) : void 0;
+		if (collection && def.collection !== collection) objects[key] = {
+			...def,
+			collection,
+			permissionCollection: def.collection
+		};
+	}
+	return {
+		...manifest,
+		objects
+	};
+}
+//#endregion
+export { separateHostedStiCollections };
+
+//# sourceMappingURL=hosted-sti-collections.js.map

package/dist/consumer-plugin/hosted-sti-collections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-sti-collections.js","names":[],"sources":["../../src/consumer-plugin/hosted-sti-collections.ts"],"sourcesContent":["/**\n * Own route collections for hosted STI subclasses (#3749).\n *\n * An STI subclass shares its base's table, and the manifest generator also\n * gives it the base's `collection` unless it declares one\n * (`@smrt({ collection })`, \"collection controls routes/permissions\n * independently of shared storage\"). Hosting `Order` and `ProductionOrder`\n * beside each other would therefore claim `/contracts` twice, and one handler\n * would silently shadow the other.\n *\n * A hosted subclass that has not declared a collection gets its class-derived\n * one (`orders`), the name it would have had as a plain model. Its generated\n * route then lists and reads through its own collection, which already scopes\n * every read to the subclass `_meta_type`; permissions do not move with it (the\n * catalog grants the STI base's `contracts.*` slugs only, #3770), so the moved\n * definition records the original collection as `permissionCollection`; the base keeps the shared name and\n * the base-collection semantics (every row of the table). The same rewritten\n * manifest feeds the `@smrt/web` definitions and the generated client, so each\n * hosted class advertises exactly the endpoint its route serves.\n */\nimport { defaultCollectionName } from '@happyvertical/smrt-scanner';\nimport type {\n  SmartObjectDefinition,\n  SmartObjectManifest,\n} from '../scanner/types.js';\nimport {\n  findManifestObjectByName,\n  isCollectionManifestClass,\n  isStiChildModel,\n  resolveCollectionItemObject,\n} from '../vite-plugin/web-collections.js';\n\n/**\n * The `api` config of the nearest STI ancestor that declares one. An omitted\n * `api` means full CRUD, so a hosted subclass that says nothing would expose\n * `DELETE /orders/:id` even though its base (`Contract`) allows only\n * list/get/create/update. Hosting fails closed: the subclass inherits the base's\n * exposure unless it declares its own (hosting path only; the framework-wide\n * default is unchanged).\n */\nfunction inheritedApi(\n  manifest: SmartObjectManifest,\n  obj: SmartObjectDefinition,\n): unknown {\n  const seen = new Set<string>();\n  let child = obj;\n  let parentName = child.extendsQualified || child.extends;\n  while (parentName && !seen.has(parentName)) {\n    seen.add(parentName);\n    const parent = findManifestObjectByName(manifest, parentName, child);\n    if (!parent) return undefined;\n    // Only an STI relative lends its exposure: it shares the table (and so the\n    // inherited collection) or is the declared STI base.\n    const sti =\n      parent.collection === obj.collection ||\n      parent.decoratorConfig?.tableStrategy === 'sti';\n    if (!sti) return undefined;\n    const api = parent.decoratorConfig?.api;\n    if (api !== undefined) return api;\n    child = parent;\n    parentName = parent.extendsQualified || parent.extends;\n  }\n  return undefined;\n}\n\n/**\n * @param manifest - The aggregated manifest of every consumed package.\n * @param hosted - Provider-qualified refs the consumer hosts.\n * @param refOf - The qualified ref of a manifest entry.\n * @returns The manifest with each hosted, collection-inheriting STI subclass\n *   moved to its own collection; `manifest` itself when none needs it.\n */\nexport function separateHostedStiCollections<M extends object>(\n  manifest: M,\n  hosted: readonly string[],\n  refOf: (key: string, def: SmartObjectDefinition) => string | undefined,\n): M {\n  const source = manifest as unknown as SmartObjectManifest;\n  const wanted = new Set(hosted);\n  let objects: SmartObjectManifest['objects'] | undefined;\n  const moved = new Map<SmartObjectDefinition, string>();\n  for (const [key, def] of Object.entries(source.objects)) {\n    const ref = refOf(key, def);\n    if (!ref || !wanted.has(ref)) continue;\n    // An explicit `collection` is already independent; only an inherited one\n    // collides.\n    const separable =\n      !def.decoratorConfig?.collection && isStiChildModel(source, def);\n    const collection = separable\n      ? defaultCollectionName(def.className)\n      : def.collection;\n    const api =\n      def.decoratorConfig?.api === undefined\n        ? inheritedApi(source, def)\n        : undefined;\n    if (collection === def.collection && api === undefined) continue;\n    if (collection !== def.collection) moved.set(def, collection);\n    objects ??= { ...source.objects };\n    objects[key] = {\n      ...def,\n      collection,\n      // The catalog keeps granting the STI base's slugs; the route must keep\n      // requiring them (#3770).\n      ...(collection === def.collection\n        ? {}\n        : { permissionCollection: def.collection }),\n      ...(api === undefined\n        ? {}\n        : { decoratorConfig: { ...def.decoratorConfig, api } }),\n    } as SmartObjectDefinition;\n  }\n  if (!objects) return manifest;\n\n  // A collection class follows its item class (the manifest generator gives it\n  // the item's collection); left behind it would keep the shared route and\n  // collide with its siblings' collection classes on custom-action routes.\n  for (const [key, def] of Object.entries(source.objects)) {\n    if (!isCollectionManifestClass(source, def)) continue;\n    const item = resolveCollectionItemObject(source, def);\n    const collection = item ? moved.get(item) : undefined;\n    if (collection && def.collection !== collection) {\n      objects[key] = {\n        ...def,\n        collection,\n        permissionCollection: def.collection,\n      } as SmartObjectDefinition;\n    }\n  }\n  return { ...manifest, objects } as M;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAS,aACP,UACA,KACS;CACT,MAAM,uBAAO,IAAI,IAAY;CAC7B,IAAI,QAAQ;CACZ,IAAI,aAAa,MAAM,oBAAoB,MAAM;CACjD,OAAO,cAAc,CAAC,KAAK,IAAI,UAAU,GAAG;EAC1C,KAAK,IAAI,UAAU;EACnB,MAAM,SAAS,yBAAyB,UAAU,YAAY,KAAK;EACnE,IAAI,CAAC,QAAQ,OAAO,KAAA;EAMpB,IAAI,EAFF,OAAO,eAAe,IAAI,cAC1B,OAAO,iBAAiB,kBAAkB,QAClC,OAAO,KAAA;EACjB,MAAM,MAAM,OAAO,iBAAiB;EACpC,IAAI,QAAQ,KAAA,GAAW,OAAO;EAC9B,QAAQ;EACR,aAAa,OAAO,oBAAoB,OAAO;CACjD;AAEF;;;;;;;;AASA,SAAgB,6BACd,UACA,QACA,OACG;CACH,MAAM,SAAS;CACf,MAAM,SAAS,IAAI,IAAI,MAAM;CAC7B,IAAI;CACJ,MAAM,wBAAQ,IAAI,IAAmC;CACrD,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,OAAO,GAAG;EACvD,MAAM,MAAM,MAAM,KAAK,GAAG;EAC1B,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,GAAG,GAAG;EAK9B,MAAM,aADJ,CAAC,IAAI,iBAAiB,cAAc,gBAAgB,QAAQ,GAAG,IAE7D,sBAAsB,IAAI,SAAS,IACnC,IAAI;EACR,MAAM,MACJ,IAAI,iBAAiB,QAAQ,KAAA,IACzB,aAAa,QAAQ,GAAG,IACxB,KAAA;EACN,IAAI,eAAe,IAAI,cAAc,QAAQ,KAAA,GAAW;EACxD,IAAI,eAAe,IAAI,YAAY,MAAM,IAAI,KAAK,UAAU;EAC5D,YAAY,EAAE,GAAG,OAAO,QAAQ;EAChC,QAAQ,OAAO;GACb,GAAG;GACH;GAGA,GAAI,eAAe,IAAI,aACnB,CAAC,IACD,EAAE,sBAAsB,IAAI,WAAW;GAC3C,GAAI,QAAQ,KAAA,IACR,CAAC,IACD,EAAE,iBAAiB;IAAE,GAAG,IAAI;IAAiB;GAAI,EAAE;EACzD;CACF;CACA,IAAI,CAAC,SAAS,OAAO;CAKrB,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,OAAO,GAAG;EACvD,IAAI,CAAC,0BAA0B,QAAQ,GAAG,GAAG;EAC7C,MAAM,OAAO,4BAA4B,QAAQ,GAAG;EACpD,MAAM,aAAa,OAAO,MAAM,IAAI,IAAI,IAAI,KAAA;EAC5C,IAAI,cAAc,IAAI,eAAe,YACnC,QAAQ,OAAO;GACb,GAAG;GACH;GACA,sBAAsB,IAAI;EAC5B;CAEJ;CACA,OAAO;EAAE,GAAG;EAAU;CAAQ;AAChC"}

package/dist/consumer-plugin/index.d.ts

@@ -11,7 +11,7 @@ export { loadVerifiedSmrtGenerationSnapshot, type SerializeSmrtGenerationSnapsho
  * `objects` is an HTTP exposure boundary: every entry must be an exact,
  * provider-qualified manifest key (for example, `@acme/widgets:Widget`).
  */
-export interface SmrtConsumerSvelteKitOptions extends Partial<Pick<SvelteKitOptions, 'routesDir' | 'configPath' | 'configFileName' | 'kebabRoutes' | 'changesRoute' | 'eventsRoute' | 'resourcesRoute'>> {
+export interface SmrtConsumerSvelteKitOptions extends Partial<Pick<SvelteKitOptions, 'routesDir' | 'objectsDir' | 'configPath' | 'configFileName' | 'kebabRoutes' | 'changesRoute' | 'eventsRoute' | 'resourcesRoute'>> {
     objects: readonly string[];
 }
 export interface SmrtConsumerOptions {

package/dist/consumer-plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/consumer-plugin/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AAYnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uCAAuC,CAAC;AAoB/C,OAAO,EACL,kCAAkC,EAClC,KAAK,sCAAsC,EAC3C,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,+BAA+B,EAC/B,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AAqDnC;;;;GAIG;AACH,MAAM,WAAW,4BACf,SAAQ,OAAO,CACb,IAAI,CACF,gBAAgB,EACd,WAAW,GACX,YAAY,GACZ,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,aAAa,GACb,gBAAgB,CACnB,CACF;IACD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,4BAA4B,CAAC;IACnD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AA2VD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA2WtE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/consumer-plugin/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AAYnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uCAAuC,CAAC;AAqB/C,OAAO,EACL,kCAAkC,EAClC,KAAK,sCAAsC,EAC3C,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,+BAA+B,EAC/B,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AAqDnC;;;;GAIG;AACH,MAAM,WAAW,4BACf,SAAQ,OAAO,CACb,IAAI,CACF,gBAAgB,EACd,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,aAAa,GACb,gBAAgB,CACnB,CACF;IACD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,4BAA4B,CAAC;IACnD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAmXD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAoYtE"}