@intentius/chant 0.72.4 → 0.72.5

package/dist/declarable.d.ts

@@ -40,7 +40,52 @@ export interface CoreOutput extends Declarable {
     readonly value: unknown;
 }
 /**
- * Type guard to check if a value is a Declarable
+ * Type guard to check if a value is a Declarable.
+ *
+ * chant#2444 — accepts an entity a HOST built, not only one chant built.
+ *
+ * `F-Host-Interface` item 1 says an entity carries a non-enumerable declarable
+ * marker, and a host supplies its own: the specification's conformance host
+ * marks with `Symbol.for("tsad.conformance.declarable")`. Testing identity
+ * against chant's symbol alone refused those for not being chant's rather than
+ * for being malformed, which is what chant#2442 hit inside composite member
+ * validation and what would otherwise keep biting in the entity tallies and the
+ * revival pass-through.
+ *
+ * ## Why NOT the reference implementation's reading
+ *
+ * The reference reads L6.1 as "any own symbol or non-enumerable own property",
+ * which is right in its domain and **unsafe in chant's**. Two measurements say
+ * so, and both were taken rather than assumed:
+ *
+ *   - A real chant entity's non-enumerable own NAMES are `lexicon`,
+ *     `entityType`, `kind`, `props`, `attributes`, `Ref`. "Any non-enumerable
+ *     own property" is therefore close to "any chant object at all".
+ *   - chant has SEVEN marker symbols, not one — `chant.intrinsic`,
+ *     `chant.composite`, `chant.stackOutput`, `chant.lexiconOutput`,
+ *     `chant.effect-receipt`, `chant.secret-declaration`, `chant.childProject`
+ *     — each a non-enumerable own symbol set to `true`. Under "any own symbol"
+ *     an Intrinsic and a StackOutput both classify as Declarable, which is a
+ *     worse bug than the one being fixed: they would enter the entity tallies.
+ *
+ * The reference can read any symbol because its domain has one. chant
+ * distinguishes seven kinds BY symbol identity, so it needs the marker's name.
+ * Hence the suffix: the marker must say `declarable`, whoever owns it.
+ *
+ * ## What the suffix cannot do
+ *
+ * It is a convention, not a registry. A host that marks with, say,
+ * `Symbol.for("acme.entity")` carries a perfectly good non-enumerable marker
+ * and is refused here, because nothing in this function knows that package is
+ * one the caller named. The context that would settle it —
+ * `FoldProjectOptions.lexiconPackages`, chant#2438 — lives in the fold path and
+ * does not reach a type guard called from a dozen places.
+ *
+ * That is a deliberate trade, not an oversight: a convention that refuses an
+ * unknown-but-valid marker costs a host one symbol name, while a rule loose
+ * enough to accept any marker miscounts chant's own seven kinds on every build.
+ * If a real host ever needs the other side of it, the fix is to thread the
+ * named packages through rather than to widen the test.
  */
 export declare function isDeclarable(value: unknown): value is Declarable;
 /**

package/dist/declarable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declarable.d.ts","sourceRoot":"","sources":["../src/declarable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAiC,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;IACnD,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,IAAI,kBAAkB,CAEnF;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAOhE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE/D"}
+{"version":3,"file":"declarable.d.ts","sourceRoot":"","sources":["../src/declarable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAiC,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;IACnD,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,IAAI,kBAAkB,CAEnF;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAKhE;AAeD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE/D"}

package/dist/discovery/sandbox/driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/driver.ts"],"names":[],"mappings":"AA4DA,MAAM,WAAW,qBAAqB;IACpC,qIAAqI;IACrI,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oNAAoN;IACpN,SAAS,EAAE,MAAM,CAAC;CACnB;AAOD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CA6F3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6CrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAmGjF"}
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/driver.ts"],"names":[],"mappings":"AA4DA,MAAM,WAAW,qBAAqB;IACpC,qIAAqI;IACrI,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oNAAoN;IACpN,SAAS,EAAE,MAAM,CAAC;CACnB;AAOD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAsH3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6CrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAmGjF"}

package/dist/fold/subset.d.ts

@@ -207,13 +207,25 @@ import { type IntrinsicDef } from "../lexicon.js";
  *   binding whatever an invoked factory returns is what chant never checked
  *   (`L8.19`), and a declarator reaching a call through a const alias is what
  *   chant resolves while refusing a call nested elsewhere (`L2.18`).
+ * - **1.7** put `F-Eval-CallLocal` before the two registered call shapes, so a
+ *   call through a name the project bound is the project function's call
+ *   whatever the registry says. That is what chant's whole-build fold already
+ *   did, and the reason the specification moved rather than chant: probes with
+ *   chant's own `output` showed the binding-first order living in
+ *   `resolveCallExpression`, while `L2.11` described the expression
+ *   classifier. The two were never required to share an order.
+ * - **1.8** added `ι = executing`, and chant carries it as of `0.72.3`
+ *   (#2455) — `FoldProjectOptions.executing`, mutually exclusive with
+ *   `sandbox`. `open` stays the default and stays strict (#2453).
  *
  * `scripts/check-docs-citations.ts` refuses to run when this constant and the
  * pinned specification disagree, so `.github/workflows/docs-check.yml` pins the
- * `spec-1.6` commit and the two move together. That coupling is deliberate: it
- * is what stops the docs being gated against a rule set nobody writes against.
+ * `spec-1.8` commit and the two move together. That coupling is deliberate: it
+ * is what stops the docs being gated against a rule set nobody writes against
+ * — which is exactly what happened while this sat at `1.0` through six
+ * versions, passing because both sides were equally stale.
  */
-export declare const SPEC_VERSION = "1.6";
+export declare const SPEC_VERSION = "1.8";
 /** The two EVL rule ids a shape violation can be attributed to. */
 export type SubsetRuleId = "EVL001" | "EVL003";
 /** A located, shape-level rejection: the offending node, the EVL rule id it maps to, and a message. */

package/dist/fold/subset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAiD,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAchE,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAG/D,CAAC;AAEH,gHAAgH;AAChH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,IAAI,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAE9D;AAED,6GAA6G;AAC7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAErG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,SAAK,GAAG,MAAM,CAGnE;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAoDpF;AAgCD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAEzE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAE1E;AAED,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAErE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,wBAAwB,EACjC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAc7B;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAkO7B"}
+{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAiD,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAchE,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAG/D,CAAC;AAEH,gHAAgH;AAChH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,IAAI,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAE9D;AAED,6GAA6G;AAC7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAErG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,SAAK,GAAG,MAAM,CAGnE;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAoDpF;AAgCD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAEzE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAE1E;AAED,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAErE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,wBAAwB,EACjC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAc7B;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAkO7B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.72.4",
+  "version": "0.72.5",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/declarable-host-marker.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, expect } from "vitest";
+import { isDeclarable, DECLARABLE_MARKER } from "./declarable";
+import { INTRINSIC_MARKER } from "./intrinsic";
+import { STACK_OUTPUT_MARKER } from "./stack-output";
+import { COMPOSITE_MARKER } from "./composite";
+
+/**
+ * chant#2444 — `isDeclarable` accepts an entity a HOST built.
+ *
+ * `F-Host-Interface` item 1 says an entity carries a non-enumerable declarable
+ * marker, and a host supplies its own. Testing identity against chant's symbol
+ * alone refused those for not being chant's rather than for being malformed —
+ * which is what chant#2442 hit inside composite member validation, and what
+ * would otherwise keep biting in the entity tallies and the revival
+ * pass-through, where it fails silently rather than loudly.
+ *
+ * The interesting half of this test file is the second describe block. The
+ * reference implementation reads the same rule as "any own symbol or
+ * non-enumerable own property", which is right for a domain with one marker and
+ * wrong for chant, which has seven. Those cases pin the narrowing.
+ */
+function marked(symbol: symbol, value: unknown = true): object {
+  const o = {};
+  Object.defineProperty(o, symbol, { value, enumerable: false });
+  return o;
+}
+
+describe("isDeclarable accepts a host's marker (chant#2444)", () => {
+  test("chant's own marker, which is every entity a chant build makes", () => {
+    expect(isDeclarable(marked(DECLARABLE_MARKER))).toBe(true);
+  });
+
+  test("the specification host's marker", () => {
+    // The exact symbol `@tsad/shapes` uses. This is the case chant#2442 hit.
+    expect(isDeclarable(marked(Symbol.for("tsad.conformance.declarable")))).toBe(true);
+  });
+
+  test("any implementation's, as long as the marker says declarable", () => {
+    expect(isDeclarable(marked(Symbol.for("some.other.tool.declarable")))).toBe(true);
+  });
+
+  test("a plain object is not one", () => {
+    expect(isDeclarable({})).toBe(false);
+    expect(isDeclarable({ entityType: "Bucket", props: {} })).toBe(false);
+    expect(isDeclarable(null)).toBe(false);
+    expect(isDeclarable("Bucket")).toBe(false);
+  });
+});
+
+describe("the narrowing, and why the reference's reading is unsafe here", () => {
+  test("chant's OTHER markers are not declarable markers", () => {
+    // The measurement that decided the implementation. Under "any own symbol",
+    // every one of these classifies as an entity and enters the tallies — a
+    // worse bug than the one chant#2444 fixes.
+    expect(isDeclarable(marked(INTRINSIC_MARKER))).toBe(false);
+    expect(isDeclarable(marked(STACK_OUTPUT_MARKER))).toBe(false);
+    expect(isDeclarable(marked(COMPOSITE_MARKER))).toBe(false);
+  });
+
+  test("a non-enumerable own NAME is not a marker either", () => {
+    // A real chant entity's non-enumerable own names are `lexicon`,
+    // `entityType`, `kind`, `props`, `attributes` and `Ref`. Reading "any
+    // non-enumerable own property" as the marker is close to "any chant object".
+    const o = {};
+    Object.defineProperty(o, "props", { value: {}, enumerable: false });
+    Object.defineProperty(o, "entityType", { value: "Bucket", enumerable: false });
+    expect(isDeclarable(o)).toBe(false);
+  });
+
+  test("an ENUMERABLE declarable symbol is refused", () => {
+    // F-Host-Interface item 1 says non-enumerable, and it matters: an
+    // enumerable marker travels through a spread and would reach an artifact.
+    const o = {};
+    Object.defineProperty(o, Symbol.for("x.declarable"), { value: true, enumerable: true });
+    expect(isDeclarable(o)).toBe(false);
+  });
+
+  test("a declarable symbol whose value is not true is refused", () => {
+    expect(isDeclarable(marked(Symbol.for("x.declarable"), false))).toBe(false);
+    expect(isDeclarable(marked(Symbol.for("x.declarable"), "yes"))).toBe(false);
+  });
+
+  test("a symbol that merely contains the word is refused", () => {
+    // Suffix, not substring: `declarable.thing` is not a declarable marker.
+    expect(isDeclarable(marked(Symbol.for("x.declarable.thing")))).toBe(false);
+    expect(isDeclarable(marked(Symbol.for("notdeclarable")))).toBe(false);
+  });
+});

package/src/declarable.ts

@@ -48,15 +48,80 @@ export interface CoreOutput extends Declarable {
 }
 
 /**
- * Type guard to check if a value is a Declarable
+ * The suffix a declarable marker's symbol description ends with.
+ *
+ * chant#2444 — what makes a marker mean "entity" rather than "some other kind
+ * of chant value". `Symbol.for("chant.declarable")` has it; so does the
+ * specification host's `Symbol.for("tsad.conformance.declarable")`.
+ */
+const DECLARABLE_MARKER_SUFFIX = ".declarable";
+
+/**
+ * Type guard to check if a value is a Declarable.
+ *
+ * chant#2444 — accepts an entity a HOST built, not only one chant built.
+ *
+ * `F-Host-Interface` item 1 says an entity carries a non-enumerable declarable
+ * marker, and a host supplies its own: the specification's conformance host
+ * marks with `Symbol.for("tsad.conformance.declarable")`. Testing identity
+ * against chant's symbol alone refused those for not being chant's rather than
+ * for being malformed, which is what chant#2442 hit inside composite member
+ * validation and what would otherwise keep biting in the entity tallies and the
+ * revival pass-through.
+ *
+ * ## Why NOT the reference implementation's reading
+ *
+ * The reference reads L6.1 as "any own symbol or non-enumerable own property",
+ * which is right in its domain and **unsafe in chant's**. Two measurements say
+ * so, and both were taken rather than assumed:
+ *
+ *   - A real chant entity's non-enumerable own NAMES are `lexicon`,
+ *     `entityType`, `kind`, `props`, `attributes`, `Ref`. "Any non-enumerable
+ *     own property" is therefore close to "any chant object at all".
+ *   - chant has SEVEN marker symbols, not one — `chant.intrinsic`,
+ *     `chant.composite`, `chant.stackOutput`, `chant.lexiconOutput`,
+ *     `chant.effect-receipt`, `chant.secret-declaration`, `chant.childProject`
+ *     — each a non-enumerable own symbol set to `true`. Under "any own symbol"
+ *     an Intrinsic and a StackOutput both classify as Declarable, which is a
+ *     worse bug than the one being fixed: they would enter the entity tallies.
+ *
+ * The reference can read any symbol because its domain has one. chant
+ * distinguishes seven kinds BY symbol identity, so it needs the marker's name.
+ * Hence the suffix: the marker must say `declarable`, whoever owns it.
+ *
+ * ## What the suffix cannot do
+ *
+ * It is a convention, not a registry. A host that marks with, say,
+ * `Symbol.for("acme.entity")` carries a perfectly good non-enumerable marker
+ * and is refused here, because nothing in this function knows that package is
+ * one the caller named. The context that would settle it —
+ * `FoldProjectOptions.lexiconPackages`, chant#2438 — lives in the fold path and
+ * does not reach a type guard called from a dozen places.
+ *
+ * That is a deliberate trade, not an oversight: a convention that refuses an
+ * unknown-but-valid marker costs a host one symbol name, while a rule loose
+ * enough to accept any marker miscounts chant's own seven kinds on every build.
+ * If a real host ever needs the other side of it, the fix is to thread the
+ * named packages through rather than to widen the test.
  */
 export function isDeclarable(value: unknown): value is Declarable {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    DECLARABLE_MARKER in value &&
-    (value as Record<symbol, unknown>)[DECLARABLE_MARKER] === true
-  );
+  if (typeof value !== "object" || value === null) return false;
+  // chant's own, which is every entity a chant build makes.
+  if ((value as Record<symbol, unknown>)[DECLARABLE_MARKER] === true) return true;
+  return carriesForeignDeclarableMarker(value);
+}
+
+/** A declarable marker some other implementation owns — see {@link isDeclarable}. */
+function carriesForeignDeclarableMarker(value: object): boolean {
+  for (const marker of Object.getOwnPropertySymbols(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, marker);
+    // Non-enumerable and `true`, per F-Host-Interface item 1. An enumerable
+    // symbol would travel through a spread and reach an artifact, which a
+    // marker must not.
+    if (descriptor === undefined || descriptor.enumerable || descriptor.value !== true) continue;
+    if (marker.description?.endsWith(DECLARABLE_MARKER_SUFFIX) === true) return true;
+  }
+  return false;
 }
 
 /**

package/src/discovery/sandbox/driver.ts

@@ -85,6 +85,7 @@ export function generateDriverSource(options: GenerateDriverOptions): string {
     `import { classifyChildError } from ${lit(CHILD_ERRORS_MODULE)};`,
     `import { getProvenance } from ${lit(PROVENANCE_MODULE)};`,
     `import { setBuildParams } from ${lit(PARAMS_MODULE)};`,
+    `import { writeSync } from "node:fs";`,
     ``,
     `const BUILD_ROOT = ${lit(buildRoot)};`,
     ``,
@@ -95,7 +96,29 @@ export function generateDriverSource(options: GenerateDriverOptions): string {
     // them exactly. Bound before any project import below.
     `setBuildParams(${lit({ ...currentBuildParams })});`,
     ``,
+    // chant#2461 — which file was being imported when the loop drained.
+    //
+    // A project file whose module scope awaits something that never settles
+    // makes its `await import(...)` never complete. Nothing keeps the loop
+    // alive, so Node exits 0 having sent nothing, and `main().catch` never
+    // fires because an unsettled promise is not a rejection. The parent then
+    // knows only that the child vanished.
+    //
+    // The child DOES know, right up to the moment it exits. `process.on("exit")`
+    // runs synchronously, so it cannot `process.send` — that is asynchronous and
+    // the channel will never be serviced — but a synchronous `writeSync` to fd 2
+    // lands, and the parent already captures and forwards stderr.
+    `let importing;`,
+    `let reported = false;`,
+    `process.on("exit", () => {`,
+    `  if (reported || importing === undefined) return;`,
+    `  writeSync(2, "chant: this file's module scope never finished evaluating, so the build could not " +`,
+    `    "report anything: " + importing + "\\n  A top-level \`await\` that never settles does this. " +`,
+    `    "Nothing is thrown, so nothing else can name it (chant#2461).\\n");`,
+    `});`,
+    ``,
     `function send(payload) {`,
+    `  reported = true;`,
     `  if (typeof process.send === "function") process.send(payload);`,
     `  else console.log(JSON.stringify(payload));`,
     `}`,
@@ -115,12 +138,14 @@ export function generateDriverSource(options: GenerateDriverOptions): string {
 
   for (const file of files) {
     lines.push(
+      `  importing = ${lit(file)};`,
       `  try {`,
       `    const mod = await import(${lit(file)});`,
       `    modules.push({ file: ${lit(file)}, exports: mod });`,
       `  } catch (err) {`,
       `    errors.push(classifyChildError(${lit(file)}, err).toJSON());`,
       `  }`,
+      `  importing = undefined;`,
     );
   }
 

package/src/discovery/sandbox/fork-diagnostic.test.ts

@@ -108,7 +108,15 @@ describe("why a sandboxed child ends without a result (chant#2461)", () => {
 
       const message = result.errors.map((e) => e.message).join("\n");
       expect(message).toContain("child exited before reporting results (code 0, signal null)");
-      expect(message).toContain("drained its loop without sending");
+
+      // chant#2461's user-facing half: the child names the file it was
+      // importing when its loop drained. It cannot `process.send` from an exit
+      // handler — that is asynchronous and the channel will never be serviced —
+      // so it writes synchronously to stderr, which the parent captures and
+      // forwards. Without this the build dies silently and nothing anywhere
+      // says which file.
+      expect(message).toContain("never finished evaluating");
+      expect(message).toContain("hangs.ts");
       expect(message).toContain("top-level");
     } finally {
       rmSync(root, { recursive: true, force: true });

package/src/fold/subset.ts

@@ -210,13 +210,25 @@ import { intrinsicCallFolds, intrinsicCallFoldsEagerly, type IntrinsicDef } from
  *   binding whatever an invoked factory returns is what chant never checked
  *   (`L8.19`), and a declarator reaching a call through a const alias is what
  *   chant resolves while refusing a call nested elsewhere (`L2.18`).
+ * - **1.7** put `F-Eval-CallLocal` before the two registered call shapes, so a
+ *   call through a name the project bound is the project function's call
+ *   whatever the registry says. That is what chant's whole-build fold already
+ *   did, and the reason the specification moved rather than chant: probes with
+ *   chant's own `output` showed the binding-first order living in
+ *   `resolveCallExpression`, while `L2.11` described the expression
+ *   classifier. The two were never required to share an order.
+ * - **1.8** added `ι = executing`, and chant carries it as of `0.72.3`
+ *   (#2455) — `FoldProjectOptions.executing`, mutually exclusive with
+ *   `sandbox`. `open` stays the default and stays strict (#2453).
  *
  * `scripts/check-docs-citations.ts` refuses to run when this constant and the
  * pinned specification disagree, so `.github/workflows/docs-check.yml` pins the
- * `spec-1.6` commit and the two move together. That coupling is deliberate: it
- * is what stops the docs being gated against a rule set nobody writes against.
+ * `spec-1.8` commit and the two move together. That coupling is deliberate: it
+ * is what stops the docs being gated against a rule set nobody writes against
+ * — which is exactly what happened while this sat at `1.0` through six
+ * versions, passing because both sides were equally stale.
  */
-export const SPEC_VERSION = "1.6";
+export const SPEC_VERSION = "1.8";
 
 /** The two EVL rule ids a shape violation can be attributed to. */
 export type SubsetRuleId = "EVL001" | "EVL003";