@dforge-core/metadata 0.0.24 → 0.0.26

package/CHANGELOG.md

@@ -5,6 +5,61 @@ All notable changes to `@dforge-core/metadata` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.26] — 2026-09-15
+
+### Added
+
+- **`traitFieldConflicts()` and the `TraitFieldConflict` type** report the collisions
+  that make the installer refuse an entity: a trait contributing a field the entity
+  already has under a different type identity (`columnType ?? dbDatatype ??
+  fieldTypeCd`, the identity `TraitExpander.TryAddField` compares). Install throws on
+  one, so a module that hits it cannot install — offline readers now name the field,
+  both types, and whether the definition being kept is an authored field or another
+  trait's. Expansion itself stays total, so an editor can still draw a field list.
+
+### Fixed
+
+- **A field code that names an inherited property is a field like any other.** The
+  merge read `sink.fields[key]` against a plain object, so a trait defining
+  `constructor` found `Object.prototype`'s, contributed no column, and reported a
+  conflict against a type identity read off a function. Own-property lookups
+  throughout, on a prototype-less merge map — which also fixes the write side, where a
+  field named `__proto__` set the prototype instead of a key — and on the
+  `localTraits` lookup, which is parsed JSON with the same hazard.
+
+- **Two templated keys that collide on one entity are a conflict, not a silent
+  overwrite.** A trait defining both `{entity}_id` and `x_id` collapsed them while
+  templating, for entity `x`, before the merge ever saw them: the later definition won
+  and nothing was reported, while install rejected the entity. Each field is now
+  resolved and merged on its own, the way the installer resolves and adds one key at a
+  time — the first definition wins, the second is reported.
+
+## [0.0.25] — 2026-09-15
+
+### Added
+
+- **`templateChunkValue()` and the `StringArg` type** are documented as exports of
+  `@dforge-core/metadata/dsl`. Both landed in 0.0.24 without an entry:
+  `CallRef.firstStringArg` became a `StringArg`, which reads a template literal as
+  well as a quoted string — reassembled from the chunks the lexer splits one into,
+  with `interpolated` marking the `${…}` holes and a space standing in for each —
+  so a rule that reads a call's first argument sees the multi-line form too.
+
+### Fixed
+
+- **`dsl/unknown-builtin` scopes a declared helper to its block, because the
+  compiler does.** `execute:` and `onBeforeStart:` are compiled to separate
+  scripts and each gets its own `CheckUndefinedReferences` pass, so a `function`
+  declared in one is undefined in the other — and the rule, which read
+  declarations across the whole file, accepted the call that install rejects. A
+  declaration above the first header belongs to no block and stays visible to
+  both; nothing legal can sit there.
+
+- **`dsl/job-record-context` stands down on a `records` the script binds
+  itself.** `var records = select(…)` is the very refactor the rule asks for, so
+  reporting it left the author with a diagnostic that its own fix could not
+  clear. Shadowing is read exactly as the execution-mode rule already reads it.
+
 ## [0.0.24] — 2026-09-15
 
 ### Added

package/dist/dsl/index.js

@@ -1163,12 +1163,20 @@ function checkDsl(text, ctx = {}) {
       );
     }
   }
-  const declaredFunctions = /* @__PURE__ */ new Set();
+  const declaredFunctions = /* @__PURE__ */ new Map();
   for (let i = 0; i < parsed.tokens.length; i++) {
-    if (parsed.tokens[i].text !== "function") continue;
+    const token = parsed.tokens[i];
+    if (token.text !== "function") continue;
     const name = parsed.tokens[i + 1];
-    if (name?.kind === "ident") declaredFunctions.add(name.text);
+    if (name?.kind !== "ident") continue;
+    const blocks = declaredFunctions.get(name.text) ?? /* @__PURE__ */ new Set();
+    blocks.add(blockOf(parsed, token.start));
+    declaredFunctions.set(name.text, blocks);
   }
+  const isDeclaredIn = (name, block) => {
+    const blocks = declaredFunctions.get(name);
+    return blocks !== void 0 && (blocks.has(null) || blocks.has(block));
+  };
   const reportedUnknown = /* @__PURE__ */ new Set();
   for (const call of parsed.calls) {
     if (call.block !== "execute" && call.block !== "onBeforeStart") continue;
@@ -1180,7 +1188,7 @@ function checkDsl(text, ctx = {}) {
       if (isMethodName(parsed.tokens, idx)) continue;
     }
     if (BUILTIN_BY_NAME.has(name) || CONTROL_KEYWORDS.has(name) || KEYWORDS_BEFORE_PAREN.has(name) || JS_GLOBALS.has(name) || FORMULA_ONLY.has(name) || // Its own rule reports this one, with better wording.
-    name === "userId" || declaredFunctions.has(name) || parsed.locals.has(name) || reportedUnknown.has(name)) {
+    name === "userId" || isDeclaredIn(name, call.block) || parsed.locals.has(name) || reportedUnknown.has(name)) {
       continue;
     }
     reportedUnknown.add(name);
@@ -1205,9 +1213,11 @@ function checkDsl(text, ctx = {}) {
       if (ref.global !== "old" || !inScript(ref.block)) continue;
       bound.push({ span: ref.span, read: `old[${ref.property}]` });
     }
-    for (const span of parsed.recordsRefs) {
-      if (!inScript(blockOf(parsed, span.start))) continue;
-      bound.push({ span, read: "records" });
+    if (!parsed.locals.has("records")) {
+      for (const span of parsed.recordsRefs) {
+        if (!inScript(blockOf(parsed, span.start))) continue;
+        bound.push({ span, read: "records" });
+      }
     }
     const first = bound.sort((a, b) => a.span.start - b.span.start)[0];
     if (first) {