@intentius/chant 0.20.0 → 0.22.0

package/src/codegen/docs-sections.test.ts

@@ -32,11 +32,16 @@ describe("generateIntrinsics — Folds? column", () => {
     expect(page).toContain("| `Sub` | — | `Sub` | Yes | Yes |");
   });
 
-  test("a plain-call intrinsic does not fold today", () => {
+  test("a plain-call intrinsic its lexicon never opted in does not fold", () => {
     const page = generateIntrinsics(config, manifestWith([{ name: "Ref", isTag: false }]));
     expect(page).toContain("| `Ref` | — | `Ref` | No | No |");
   });
 
+  test("a plain-call intrinsic opted into call-form folding does fold (chant #1044)", () => {
+    const page = generateIntrinsics(config, manifestWith([{ name: "Ref", isTag: false, foldsAsCall: true }]));
+    expect(page).toContain("| `Ref` | — | `Ref` | No | Yes |");
+  });
+
   test("an intrinsic with isTag omitted does not fold (same as isTag: false)", () => {
     const page = generateIntrinsics(config, manifestWith([{ name: "reference", outputKey: "!reference" }]));
     expect(page).toContain("| `reference` | — | `!reference` | No | No |");
@@ -47,6 +52,7 @@ describe("generateIntrinsics — Folds? column", () => {
       { name: "Sub", isTag: true },
       { name: "Ref" },
       { name: "GetAtt", isTag: false },
+      { name: "Join", isTag: false, foldsAsCall: true },
     ];
     const page = generateIntrinsics(config, manifestWith(intrinsics));
     for (const fn of intrinsics) {

package/src/codegen/docs-sections.ts

@@ -95,7 +95,7 @@ export function generateIntrinsics(
     "",
     `The ${config.displayName} lexicon provides **${intrinsics.length}** intrinsic functions.`,
     "",
-    `**Tag?** shows how an intrinsic is authored: a genuine tagged template (\`Sub\\\`...\\\`\`) or a plain function call (\`Ref(...)\`). **Folds?** shows whether [\`chant build --fold\`](/chant/concepts/typescript-as-data/#folded-vs-run) can reduce a call to this intrinsic today, without running the file — generated directly from this lexicon's registration, not restated by hand. Right now folding only reaches tagged templates, so most rows read \`No\`; that reflects the current state of the folder, not something specific to these intrinsics, and it changes as folding gains coverage.`,
+    `**Tag?** shows how an intrinsic is authored: a genuine tagged template (\`Sub\\\`...\\\`\`) or a plain function call (\`Ref(...)\`). **Folds?** shows whether [\`chant build --fold\`](/chant/concepts/typescript-as-data/#folded-vs-run) can reduce a use of this intrinsic today, without running the file — generated directly from this lexicon's registration, not restated by hand. A tagged template folds once it is registered. A plain call folds only where this lexicon has opted that intrinsic in one at a time (\`foldsAsCall\`), so a \`No\` in this column means this intrinsic has not been opted in, not that calls in general cannot fold.`,
     "",
     "| Function | Description | Output Key | Tag? | Folds? |",
     "|----------|-------------|------------|------|--------|",

package/src/codegen/docs-types.ts

@@ -55,6 +55,8 @@ export interface ManifestJSON {
     description?: string;
     outputKey?: string;
     isTag?: boolean;
+    /** chant #1044 — the call-form fold opt-in, as published in the lexicon's manifest. Absent in any manifest built before #1044, which reads the same as "not opted in". */
+    foldsAsCall?: boolean;
   }>;
   pseudoParameters?: Record<string, string>;
 }

package/src/declarable.ts

@@ -13,6 +13,26 @@ export interface Declarable {
   readonly [DECLARABLE_MARKER]: true;
 }
 
+/**
+ * A `Declarable` that carries a resource payload — the `props`/`attributes`
+ * fields that most lexicon serializers read to produce output. Not every
+ * `Declarable` has one (outputs and parameters genuinely don't), so this is
+ * kept as a sub-interface rather than widening the base type. See chant #1049.
+ */
+export interface ResourceDeclarable extends Declarable {
+  readonly props: unknown;
+  readonly attributes?: unknown;
+}
+
+/**
+ * Type guard for `ResourceDeclarable` — replaces the ad-hoc `"props" in x`
+ * checks that were previously repeated (with an `as unknown as` cast) at every
+ * call site that reads `props`/`attributes` off a `Declarable`.
+ */
+export function isResourceDeclarable(value: Declarable): value is ResourceDeclarable {
+  return "props" in value;
+}
+
 /**
  * Core parameter type for lexicon-agnostic parameters
  */

package/src/discovery/entity-wire-codec.ts

@@ -54,7 +54,7 @@
  * today.
  */
 
-import { DECLARABLE_MARKER, type Declarable } from "../declarable";
+import { DECLARABLE_MARKER, isResourceDeclarable, type Declarable } from "../declarable";
 import { AttrRef } from "../attrref";
 import { INTRINSIC_MARKER, type Intrinsic } from "../intrinsic";
 import { isAttrRefLike } from "../utils";
@@ -256,7 +256,7 @@ function encodeValue(value: unknown, entityNames: Map<unknown, string>): WireVal
     // directly rather than walking `resource` as a Declarable reference).
     // Inline exactly that, discarding the unresolvable (and, in every corpus
     // entry today, unread) identity layer.
-    const props = "props" in decl ? (decl as unknown as { props?: unknown }).props : undefined;
+    const props = isResourceDeclarable(decl) ? decl.props : undefined;
     return { __property: { lexicon: decl.lexicon, entityType: decl.entityType, props: props !== undefined ? encodeValue(props, entityNames) : undefined } };
   }
 
@@ -280,11 +280,13 @@ function encodeDeclarable(entity: Declarable, entityNames: Map<unknown, string>)
   const wire: Omit<WireDeclarableEntity, "form" | "name"> = { lexicon: entity.lexicon, entityType: entity.entityType, markers: [] };
   if (entity.kind !== undefined) wire.kind = entity.kind;
 
-  if ("props" in entity && (entity as unknown as { props?: unknown }).props !== undefined) {
-    wire.props = encodeValue((entity as unknown as { props: unknown }).props, entityNames);
-  }
-  if ("attributes" in entity && (entity as unknown as { attributes?: unknown }).attributes !== undefined) {
-    wire.attributes = encodeValue((entity as unknown as { attributes: unknown }).attributes, entityNames);
+  if (isResourceDeclarable(entity)) {
+    if (entity.props !== undefined) {
+      wire.props = encodeValue(entity.props, entityNames);
+    }
+    if (entity.attributes !== undefined) {
+      wire.attributes = encodeValue(entity.attributes, entityNames);
+    }
   }
 
   const markers: string[] = [];