@metaobjectsdev/sdk 0.14.1 → 0.15.0-rc.1

package/agent-context/skills/metaobjects-audit/SKILL.md

@@ -69,7 +69,35 @@ code behind a grep hit; a "duplicate" validator's *divergence* is the finding.
   (ADR-0019); runtime reflection to resolve a type from FQN vs generated static imports /
   FQN registry (ADR-0001 / 0017); process-global registry vs per-loader (ADR-0014); code
   that **mutates the loaded metadata tree** (read-only after load); JVM/Kotlin missing
-  startup validator; writes not routed to the `@role: primary` source.
+  startup validator; writes not routed to the `@role: primary` source; **`own*()`
+  accessor reads of effective properties / own-only member iteration (ADR-0039 — see
+  the active check below).**
+
+- [ ] **G2. `own*()` accessor discipline (ADR-0039 — CORRECTNESS DEFECT, not advisory).**
+  In any custom generator, metamodel provider, or runtime path (NOT the sanctioned cases
+  below), **flag every read of a field/node's effective property, or own-only member
+  iteration, done through an own-only accessor** — it silently drops everything inherited
+  via `extends` (a super-reference, not a flatten), corrupting codegen and runtime. This
+  is exactly the class of bug that broke Kotlin's array-type derivation (a concrete field
+  inheriting an array flag from an abstract parent generated a scalar) and, per the audit,
+  is latent cross-port. Grep for the own-only accessors and verify each hit:
+  - **TS:** `ownAttr(`, `ownChildren(`, `ownFields(`, a raw `isArray` field flag read →
+    should be `attr(` / `children()` / `fields()` unless emitting a subclass's own members.
+  - **Python:** `own_children(`, `own_fields(`, and the **inverted** bare `attr(` (Python
+    `attr()` is OWN; the resolving form is `attrs().get(`) → flag `attr(` used to read an
+    effective value.
+  - **Java / Kotlin:** `getMetaAttr(name, false)` (the `,false` own overload), own-only
+    child walks (e.g. an own-only `filterIsInstance<…>()` source lookup that emits nothing
+    for an entity inheriting its source).
+  - **C#:** a native `IsArray` flag read, `OwnChildren()`, own attr reads.
+
+  **Sanctioned (do NOT flag):** (a) a generator emitting a generated **subclass** that
+  iterates `ownFields()` so inherited members aren't re-emitted (the generated base
+  declares them — the `class Sub extends Base` / TPH pattern); (b) the own-mode canonical
+  serializer + overlay-merge + super-resolution walks (library-internal); (c) the single
+  deliberately-own attribute `@dbColumnType` (a physical column-type override, never
+  inherited). Any own read that carries a comment naming one of these cases is fine; an
+  uncommented own read of an effective property is the defect.
 - [ ] **H. Authoring-correctness / ADR-conformance (deep).** Invented/unregistered
   `@`-attrs or post-bootstrap registration (ADR-0023 — custom attrs belong in a registered
   provider or `attr.properties`); retired source-v2 forms (`source.dbTable` / `@name` /
@@ -80,10 +108,70 @@ code behind a grep hit; a "duplicate" validator's *divergence* is the finding.
   in committed canonical JSON (ADR-0032); DB-type-as-logical-subtype (ADR-0013); per-port
   migration engine where schema is Node-`meta`-owned (ADR-0015).
 
+- [ ] **I. Vocabulary hygiene / modernization (ADVISORY).** Flag already-retired or
+  deprecated authoring patterns and recommend the canonical form (see § Vocabulary
+  hygiene). Advisory severity — scored as modernization opportunities, **never a
+  failing finding**.
+
 **Phase 4 — Synthesize** into the tiered roadmap and populate both artifacts.
 
 ---
 
+## Vocabulary hygiene / modernization (axis I — ADVISORY)
+
+Per ADR-0037, vocabulary expansion follows ONE ordered test (derivable → derive;
+physical-only → `@dbColumnType`; logical: different native type → subtype, same kind +
+modifier → attribute). This axis surfaces authoring that predates or contradicts that
+framework. **All findings here are advisory** — modernization opportunities scored as
+such, surfaced in the roadmap, but **non-failing** (the code works; the form is dated).
+
+**Already-retired / deprecated forms → recommend the canonical form:**
+
+- `@dbColumnType: uuid_array` / `@dbColumnType: text_array` (a physical array column
+  type) → **`isArray: true`** on the base subtype. Array-ness is logical and derivable;
+  the array column type is retired.
+- The `@kind: text` hack (forcing text via a kind override) → **bare `field.string`**
+  (text is the default; no override needed).
+- `@dbColumnType: uuid` where a native UUID type is actually wanted → **`field.uuid`**
+  (a distinct native type is a subtype, not a physical override). Keep `@dbColumnType:
+  uuid` ONLY for the deliberate string-over-uuid-column case.
+- `@dbColumnType: timestamp_with_tz` (ADR-0036 Wave 2) → **drop it.** `field.timestamp` is
+  instant / timezone-aware **by default** now; the `timestamp_with_tz` column-type override
+  is **retired**. Timezone-awareness lives in `field.timestamp` + the `@localTime` opt-out.
+- A bare `field.timestamp` that is **semantically a wall-clock value** (a store-open time, a
+  birthday-with-time, a recurring local schedule) → recommend **`@localTime: true`** (naive
+  `timestamp without time zone`), or confirm it is genuinely meant to be an instant. Default
+  `field.timestamp` is an instant; only flag when the field's meaning is clearly wall-clock.
+- A `validator.regex` (or a plain `field.string`) validating an **email** shape → recommend
+  **`@stringFormat: email`** on the `field.string` (ADR-0036 Wave 3). The native type stays
+  `string`; the per-port codegen emits the idiomatic email check — don't hand-roll the regex.
+- A `field.string` that **holds a URL / URI** → recommend **`field.uri`** (native `URI`/`Uri`,
+  URL validation) — a distinct native type + behavior is a subtype, not a validated string.
+- A `field.string` that **holds an IP address** → recommend **`field.inet`** (native IP type;
+  Postgres `inet` column).
+
+**Custom-provider vocabulary (adopters who register their own types/attrs):** check
+new/custom vocab against the ADR-0037 procedure (advisory) — e.g. *a custom subtype
+that differs from an existing one only by a property should be an attribute, not a
+subtype*; an email/hostname string-validation is an **attribute** (`@stringFormat`,
+native type unchanged), while a URL or IP is a **native type** (`field.uri` /
+`field.inet`, a subtype). Recommend re-shaping against the ordered test.
+
+**Hand-rolled reverse-query repository methods (ADR-0038) → recommend the generated reverse
+FK finder.** Reverse navigation — *"find all the rows that reference this one"* — is now
+codegen. Flag a hand-written reverse-query method (a `findByParentId` / `findBy<Parent>`
+repository finder, or a manual `WHERE fk = ?` query helper — exactly what a JVM adopter
+hand-writes in its `SceneRepository`) and recommend the **generated reverse FK finder**
+instead: codegen now emits `find<Source>By<FkField>` plus a batched `…In(ids)` variant from
+the FK metadata, idiomatic per port (Spring repository finder / EF query method / Python or
+TS query function). It is **performant** (one indexed query, no N+1) and **framework-free**
+(no lazy collections / proxies). When an entity has two FKs to the same target, the codegen
+emits two distinct finders (named by the FK field) automatically — no annotation needed; the
+reverse finder is a **codegen feature, not an attribute** (there is no reverse-nav `@`-attr
+to author). Advisory severity — a modernization opportunity, not a failing finding.
+
+---
+
 ## Classification scheme (every surface; classify on codegen AND runtime)
 
 | Class | Meaning | Action |
@@ -112,6 +200,7 @@ Per finding: `file:line` → what → generated-equivalent exists? → recommend
 4. **Drift-admitting comments** — grep: `"keep in sync with"` / `"mirrors the"` / `"matching the"`.
 5. **Runtime schema patching** (`ALTER TABLE … ADD COLUMN IF NOT EXISTS`, `_ensure_schema()`) — N schema owners.
 6. **N declarations of one shape** — same entity as Drizzle table + Zod schema + Pydantic model + hand dataclass; target is 1 + N generated.
+7. **`own*()` accessor read of an effective property** (ADR-0039) — `ownAttr` / `ownFields` / `own_children` / bare Python `attr(` / `getMetaAttr(name, false)` / native `IsArray` used to read a value or iterate members outside the sanctioned subclass-emit / own-serializer / `@dbColumnType` cases → silently drops `extends`-inherited values. A **correctness defect** (axis G2), not advisory.
 
 ---
 
@@ -183,6 +272,10 @@ one-consumer need, read it codegen-locally.
 Coarse bands only (none / some / most / all). Worst-of within a pillar. On re-run, grade
 the delta. Lead with gaps, not the grade.
 
+**Vocabulary hygiene (axis I) is advisory** — it surfaces as modernization
+opportunities in the roadmap, scored as such, and **never gates a tier or fails the
+audit.** Dated-but-working vocabulary is a quality nudge, not a defect.
+
 ---
 
 ## Report

package/agent-context/skills/metaobjects-authoring/SKILL.md

@@ -151,7 +151,7 @@ name   package   extends   abstract   overlay   isArray   children   value
 | `field.double` | float | |
 | `field.boolean` | true/false | |
 | `field.date` | calendar date | ISO 8601 `YYYY-MM-DD` on the wire |
-| `field.timestamp` | instant | ISO 8601 with timezone on the wire |
+| `field.timestamp` | instant (tz-aware) | ISO 8601 with timezone on the wire; `@localTime: true` for a naive wall-clock value |
 | `field.decimal` | exact decimal | `@precision` / `@scale`; lossless money/quantity |
 | `field.currency` | integer minor units | see Currency below |
 | `field.enum` | string member | `@values` required; see Enum below |
@@ -161,6 +161,140 @@ name   package   extends   abstract   overlay   isArray   children   value
 Common field attributes: `@required`, `@maxLength`, `@column` (physical column
 name), `@default`, `@filterable`, `@sortable`.
 
+### Choosing the right shape — the general decision procedure (ADR-0037)
+
+This procedure decides the shape of **any** concept entering the metamodel — a
+field need today, or new vocabulary you register as a custom provider. It is not a
+lookup table of specific answers; it is the routing an LLM re-derives on its own
+for a concept it has never seen.
+
+**Ask what the concept *does*, never how it stores.** The guiding question is
+**semantic behavior, not surface storage**: never ask *"is X a string / a number /
+a date?"* — ask *"what does X **do**? Does it have its own native type, behavior,
+or attributes (a **thing** → subtype)? Is it a structural variant of an existing
+thing (a **kind**)? Or does it just modify, validate, or configure an existing type
+(an **attribute**)?"* Shape follows behavior. Don't be misled by tools (JSON
+Schema, Zod) that call everything a "string format" — they only do so because
+JS/JSON has no native types; MetaObjects binds metadata→native types across five
+languages, so the call is behavioral.
+
+Run the steps **in order; the first that matches decides:**
+
+| # | Test | If yes → | Examples (existing vocab) |
+|---|---|---|---|
+| 0 | **Derivable** from the existing subtype + attrs (`isArray`, `@maxLength`) + structure (`identity.reference`, relationships) + naming? | **derive it in codegen — add NOTHING** | `text[]` ← `field.string` + `isArray`; `varchar(n)` ← `@maxLength`; FK columns ← `identity.reference` |
+| 1 | **Physical-only** — pure DB-storage detail, native type *and* meaning unchanged? | narrow **`@dbColumnType`** escape hatch (sparingly; not a logical type) | open JSON bag → `field.string` + `@dbColumnType: jsonb` |
+| 2a | Its **own thing** — has its own native type, **or** its own behavior, **or** its own attributes? | **SUBTYPE** (the extension point — owns custom codegen, validation, child attrs) | `field.uuid` (native UUID), `field.currency` (minor-unit money behavior), `field.decimal` (exact) |
+| 2b | A **structural variant within** a subtype that already earned 2a — same native type/behavior, different generated *shape*? | **`@kind`** (the one chartered structural-variant axis) | `source.rdb @kind`: table/view/materializedView/storedProc/tableFunction; `template.output @kind`: document/email |
+| 2c | Otherwise it **modifies / validates / configures** an existing type | **ATTRIBUTE** (boolean flag · closed enum · validation · config) | `@localTime` (boolean exception-flag); `@maxLength`/`@precision`/`@scale` (config) |
+
+**Reading step 2 (the load-bearing split):**
+- **2a — subtype** is the metamodel's *extension point*: the only shape that owns
+  custom logic. Litmus: *"would I plausibly want to attach behavior or extra
+  attributes to this later?"* If yes → subtype. A value that merely *serializes* as
+  a string is still a subtype if the **concept** has a native type or behavior of
+  its own. (General rule, stated abstractly so it survives un-built vocab: *a
+  concept with a native type or its own behavior becomes a subtype; a plain string
+  that just needs validating becomes a validation attribute.*)
+- **2b — `@kind`** is reserved for variants *inside* a subtype that earned its place
+  by 2a. `@kind` on a plain `field.string` is wrong: a plain string isn't a
+  behavioral subtype, so there's nothing for the kinds to be *kinds of*. Never let
+  `@kind` become a catch-all discriminator.
+- **2c — attribute** shape follows what it is: a **boolean exception-flag** whose
+  common case is *absent* (`@localTime` — never a default-true opt-out); a **closed
+  set** → enum attr with `allowedValues`; a **validation constraint** that narrows a
+  value without changing its type (the thing stays a plain `<base>`, there's no
+  behavior to own — else it would be 2a); a **config value** (sizing, precision,
+  locale) → a typed attr (`@precision`/`@scale`).
+
+**Two corollaries that break ties:**
+- **Self-documentation over economy.** Prefer a specific named attribute
+  (`@localTime`, `@unique`) over folding several concerns into one generic attr. A
+  name should tell you what it does without a per-type lookup. The *primary*
+  universal discriminator is already `type.subType` — don't invent a second one.
+- **Same concept → same attr name; never same-name / different meaning.** If an attr
+  name already means something else on another type, give the new one a distinct
+  name rather than overload it.
+
+This procedure is authority-backed: **ADR-0037** is the source of truth, sequencing
+ADR-0013 (physical vs logical), ADR-0023 (derive, don't invent), and ADR-0001
+(build-time native binding).
+
+Canonical form for common field needs — reach for these before inventing anything:
+
+| Need | Author it as | Note |
+|---|---|---|
+| IDs / unique keys | `field.uuid` | native UUID; use `@dbColumnType: uuid` only to force a string-typed value over a uuid column on purpose |
+| Money | `field.currency` | integer minor units; never a float |
+| Closed set of symbols | `field.enum` | `@values` required |
+| Instant / event time (created/updated) | `field.timestamp` | instant / tz-aware by default (Postgres `timestamptz`; native `Instant`/`DateTimeOffset`/aware `datetime`) |
+| Naive wall-clock value (store-open time, birthday-with-time) | `field.timestamp` + `@localTime: true` | `timestamp without time zone` — opt out of zone-awareness only for a genuine wall-clock value |
+| A list of anything | `isArray: true` | on the base subtype (e.g. `field.string` + `isArray`) — there is **no** array `@dbColumnType` (retired) |
+| Long / unbounded text | bare `field.string` | add `@maxLength` only when you want `varchar(N)` |
+| Nested structured value | `field.object` | `@objectRef` + `@storage` |
+| Open JSON bag (no fixed shape) | `field.string` + `@dbColumnType: jsonb` | logical type stays string; column is jsonb |
+| URL / URI | `field.uri` | native `URI`/`Uri`; `text` column; URL validation — a real native type + behavior, so a subtype (not a validated string) |
+| IP address | `field.inet` | native IP type; Postgres `inet` column |
+| Validated plain string (email / hostname) | `field.string` + `@stringFormat` | `@stringFormat: email` or `@stringFormat: hostname` — idiomatic per-port validation; don't hand-write the `validator.regex` |
+
+**Timestamps — instant by default, `@localTime` for naive wall-clock (ADR-0036 Wave 2).**
+`field.timestamp` is **instant / timezone-aware by default** (Postgres `timestamptz`;
+native `Instant` / `DateTimeOffset` / aware `datetime`) — use it for created/updated/event
+times. Add **`@localTime: true`** only for a genuine naive wall-clock value (a store-open
+time, a birthday-with-time, a recurring local schedule) → `timestamp without time zone`.
+Never use `@dbColumnType: timestamp_with_tz` — it is **retired**; timezone-awareness now
+lives in `field.timestamp` (instant by default) + the `@localTime` naive opt-out.
+
+```json
+{ "field.timestamp": { "name": "createdAt", "@required": true } }
+{ "field.timestamp": { "name": "opensAt", "@localTime": true } }
+```
+
+**String-shaped natives & validated strings (ADR-0036 Wave 3).** A URL/URI is its own
+native type with URL behavior → **`field.uri`** (subtype, step 2a), not a validated
+string. An IP address likewise → **`field.inet`**. An email or hostname is a *plain
+string that just needs validating* (native type stays `string`) → **`field.string` +
+`@stringFormat: email`/`hostname`** (validation attribute, step 2c) — let the per-port
+codegen emit the idiomatic check; don't hand-write a `validator.regex` for it.
+
+```json
+{ "field.uri":    { "name": "homepage" } }
+{ "field.inet":   { "name": "lastLoginIp" } }
+{ "field.string": { "name": "email", "@stringFormat": "email", "@required": true } }
+```
+
+**Reverse navigation is generated for you (ADR-0038) — don't hand-write reverse queries.**
+The natural question *"find all the rows that reference this one"* (every `Scene` a
+`GameSession` points at, every `Message` naming a `User`) is **codegen, not authoring**.
+For each FK, the *referenced* entity's query surface gains explicit finders derived from
+the relationship + `identity.reference` metadata — idiomatic per port (a Spring repository
+finder, an EF query method, a Python query function, a TS query function):
+
+- `find<Source>By<FkField>(id)` — one indexed `WHERE <fk> = ?` lookup.
+- `find<Source>By<FkField>In(ids)` — the batched variant, one `WHERE <fk> IN (…)` for the
+  many-parent case (no N+1).
+
+They are **performant by construction** (a single indexed query, no lazy collections /
+proxies / N+1 surprises) and **framework-free** (a plain function over the query layer —
+runs without MetaObjects). When an entity has **two FKs to the same target**, you get **two
+distinct finders** automatically — named by the FK field, unique by construction. There is
+**no attribute to author** for this — reverse navigation is a *codegen feature, not a
+metamodel attribute*: you declare the FK once via `identity.reference`, and the reverse
+finders fall out of codegen. So never hand-roll a `findByParentId` / `WHERE fk = ?` helper —
+consume the generated finder.
+
+**Extending the metamodel (custom providers):** the same ordered procedure above
+governs new vocabulary you register — apply it mechanically before registering
+anything. A would-be subtype that differs from an existing one only by a *property*
+is an **attribute**, not a subtype (a "short string" isn't a new field subtype —
+that is `@maxLength`); a plain string that merely needs validating is a **validation
+attribute**, not a subtype (its native type is still `string`, and there's no
+behavior to own); a concept with its own native type or behavior is a **subtype**,
+and structural variants *within* such a subtype are `@kind`. Every new first-class
+element also requires a registered provider + a `registry-conformance` fixture
+(ADR-0023 strict provenance), and closed enums (including any `@kind` value-set)
+carry `allowedValues` in the gate (ADR-0036). ADR-0037 is the authority.
+
 ### Currency
 
 `field.currency` stores money as **integer minor units** (cents for USD, yen for
@@ -406,6 +540,16 @@ Resolution facts:
 
 `abstract` and `extends` are **structural keys** (bare, no `@`).
 
+**Extends-inherited properties are real — consume metadata through the resolving
+accessors (ADR-0039).** If you write a custom generator or a metamodel provider that
+reads this metadata, a concrete field/entity's inherited attributes and members live
+on the parent it `extends`, not on the node itself (extends is a super-*reference*, not
+a flatten). Always read a property or iterate a member set via the **resolving/effective**
+accessor (TS `attr()`/`children()`/`fields()`, Python `attrs().get()`), **never an
+`own*()` accessor** — an own-only read silently drops everything inherited via `extends`
+and corrupts the generated code. See the `metaobjects-codegen` skill for the full
+per-port mapping.
+
 **`overlay` is a different concept.** `extends:` is an IS-A relationship between
 two distinct nodes. `overlay: true` re-opens the *same* named node to amend it
 across files (same `package` + same `name` → merged; last-writer-wins on attr

package/agent-context/skills/metaobjects-codegen/SKILL.md

@@ -132,6 +132,44 @@ the `generators` array in `metaobjects.config.ts` next to the built-ins — it r
 the same pass, writes under the same target rules, and carries the `@generated`
 header so it round-trips like any other.
 
+### Never read metadata through an `own*()` accessor (ADR-0039) — top bug source
+
+When writing OR reviewing a generator, **read every field/node property and iterate
+every member set through the resolving/effective accessor — never the `own*()` form.**
+`extends` is a **super-reference, not a flatten**: a concrete field/entity that
+`extends` an abstract parent keeps its inherited attributes and members physically on
+the parent, reachable only through the *resolving* accessor. An `own*()` read of an
+effective property (`isArray`, `subType`, `maxLength`, `precision`/`scale`, `default`,
+the physical column name, `objectRef`, `storage`, `required`, …) or an own-only member
+iteration **silently drops everything inherited via `extends`** — the classic symptom
+was a concrete field that inherited `isArray: true` from an abstract parent generating
+a *scalar* column. These reads compile and pass every fixture that never exercises
+`extends`, so they are a latent, cross-port top bug source.
+
+**The one legitimate `own*()` use:** a generator emitting a generated **subclass** that
+`extends` a generated base iterates **own members** (`ownFields()`) so the inherited
+members are **not re-emitted** — the generated base class already declares them (the
+`class Sub extends Base` / TPH pattern). Everywhere else, resolve. (The own-mode
+canonical serializer and overlay-merge are the only other sanctioned own reads, and
+they are library-internal, not app-generator concerns.) The one deliberately-own
+attribute is `@dbColumnType` — a physical column-type override that is never inherited.
+
+**Per-port own↔resolving mapping** (reach for the resolving column; comment any
+`own*()` call with the sanctioned case it is):
+
+| Port | Resolving (default — use this) | Own-only (avoid unless emitting a subclass's own members) |
+|---|---|---|
+| TypeScript | `attr(name)`, `children()`, `fields()` | `ownAttr(name)`, `ownChildren()`, `ownFields()`, the raw `isArray` field flag |
+| Python | `attrs().get(name)`, `children()`, `fields()` | `attr(name)` **(own!)**, `own_children()`, `own_fields()` |
+| Java / Kotlin | `getMetaAttr(name)`, resolving `getChildren()` | `getMetaAttr(name, false)`, own-only child walks |
+| C# | resolving attr/`Children`/`Fields` accessors | `IsArray` native flag, `OwnChildren()`, own attr reads |
+
+**Naming inversion — the trap:** the *default-named* accessor is NOT consistently the
+safe one. **TS `attr()` RESOLVES; Python `attr()` is OWN** (own-only). In Python you
+must call `attrs().get(name)` to get the inherited value — a bare `attr(name)` is the
+own read that drops inheritance. When you review or port a generator, check the port's
+convention, not the method name.
+
 **Close but not exact?** You don't always need a new generator — a generated file is
 a normal source file. Copy it and customize the copy (three-way merge preserves your
 edits on regen), or customize the template a built-in renders from. Reach for a
@@ -157,6 +195,15 @@ dialect's column types deterministically (`field.string` + `@maxLength` →
 `varchar(N)`, `field.currency` → integer, `field.uuid` → native `uuid` on
 Postgres, `field.enum` → `varchar` + `CHECK`, etc.).
 
+Codegen only ever maps the **shapes you authored** — so author them right. If you
+find the generator emitting the wrong column type, the fix is the field shape, not a
+template hack. See "Choosing the right shape — the general decision procedure" in the
+**`metaobjects-authoring`** skill for the ordered derive→`@dbColumnType`→subtype/
+`@kind`/attribute routing (ADR-0037) — e.g. arrays are `isArray: true` (never an
+array column type) and a native UUID is `field.uuid` (not a string + `@dbColumnType`).
+When you register custom vocabulary for a custom generator, the same ADR-0037
+procedure decides whether it's a subtype, a `@kind` variant, or an attribute.
+
 ## Per-target output
 
 Generated code can be routed to **multiple output directories/packages** so each

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaobjectsdev/sdk",
-  "version": "0.14.1",
+  "version": "0.15.0-rc.1",
   "description": "Workspace helpers and agent-docs utilities for MetaObjects projects.",
   "type": "module",
   "main": "./dist/index.js",
@@ -56,7 +56,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@metaobjectsdev/metadata": "0.14.1",
+    "@metaobjectsdev/metadata": "0.15.0-rc.1",
     "zod": "^3.23.0"
   },
   "devDependencies": {