fix(spec): keep the assembled-body aliases key-precise but element-loose — the per-key mapped alias emitted the collections shape a second time and OOM'd the type-check-debt re-measure (#14439)

`AssembledPackageBody` / `AssembledPackageBodyParsed` referenced
`(typeof STACK_DEFINITION_COLLECTIONS_SHAPE)[K]` per collection key. Because
those aliases are exported, the declaration emit wrote the shape const into
`stack.zod-*.d.ts` a second time (21,443 lines beside the 42,449 the stack
schema already inlines), and every consumer program re-inferred all ~35
collection input/output types once more. `Type Check · debt ledger` on the
PR went red: the `qa/http-conformance` TEST_DEBT re-measure exceeded the
4096 MB ceiling the gate pins as CI's, while the merge-queue run on the base
passed the same step. Reproduced locally (exit 3) on b4b9732.

The aliases now keep the DERIVED key set (`AssembledPackageBodyKey`, still
read off `COMPOSE_KEY_DISPOSITIONS`) and type each collection as `unknown`.
Nothing exported references the shape const any more, so the second copy is
not emitted and the per-key inference does not run. `assembledPackageBodyShape()`
keeps its `Pick<typeof STACK_DEFINITION_COLLECTIONS_SHAPE, K>` return type
(internal, not emitted), so a disposition key missing from the collections
shape is still a compile error, and the RUNTIME schema still carries every
collection's full declaration — refusals are unchanged. One spec pin narrows
its element access at the point of use, as every reader of an assembled
body already does.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UHvF5hyiZjnCyExFnfQB8m

Author: claude

packages/spec/src/assembled-package-body.test.ts

@@ -240,7 +240,13 @@ describe("ADR-0130 D4 — `manifest: 'preserve'` assembles each input stack", ()
       'com.example.multi.orders',
       'com.example.multi.core',
     ]);
-    expect(parsed[1].manifest.objects?.map((o) => o.name)).toEqual(['crm_account']);
-    expect(parsed[0].manifest.objects?.map((o) => o.name)).toEqual(['crm_order']);
+    // Collections inside an assembled body are `unknown` at the TYPE level (see
+    // the note above `AssembledPackageBodySchema` — the element-precise alias
+    // OOM'd consumer type-checks); narrow at the point of use, as every reader
+    // of an assembled body does.
+    const objectNames = (objects: unknown): string[] | undefined =>
+      (objects as Array<{ name: string }> | undefined)?.map((o) => o.name);
+    expect(objectNames(parsed[1].manifest.objects)).toEqual(['crm_account']);
+    expect(objectNames(parsed[0].manifest.objects)).toEqual(['crm_order']);
   });
 });

packages/spec/src/stack.zod.ts

@@ -1028,26 +1028,45 @@ function assembledPackageBodyShape(): Pick<typeof STACK_DEFINITION_COLLECTIONS_S
  */
 export type AssembledPackageBody =
   Omit<z.input<typeof ManifestSchema>, AssembledPackageBodyKey>
-  & Partial<{ [K in AssembledPackageBodyKey]: z.input<(typeof STACK_DEFINITION_COLLECTIONS_SHAPE)[K]> }>;
+  & Partial<Record<AssembledPackageBodyKey, unknown>>;
 
 /** Post-parse shape of {@link AssembledPackageBody} — defaults applied, transforms run (ADR-0122). */
 export type AssembledPackageBodyParsed =
   Omit<z.infer<typeof ManifestSchema>, AssembledPackageBodyKey>
-  & Partial<{ [K in AssembledPackageBodyKey]: z.infer<(typeof STACK_DEFINITION_COLLECTIONS_SHAPE)[K]> }>;
+  & Partial<Record<AssembledPackageBodyKey, unknown>>;
 
 /*
- * ANNOTATED, not inferred, and the annotation is derived rather than
- * transcribed (the two aliases above are mapped over the same key set the value
- * is built from). Inferring it emits the manifest and all ~35 collection
+ * ANNOTATED, not inferred, and the annotation is KEY-precise but
+ * ELEMENT-loose — both halves measured, neither a preference.
+ *
+ * Not inferred: inferring it emits the manifest and all ~35 collection
  * declarations a SECOND time inside `ObjectStackDefinitionSchema`'s own
  * inferred type, which `tsc` refuses to serialize at all:
  *
  *   TS7056: The inferred type of this node exceeds the maximum length the
  *           compiler will serialize. An explicit type annotation is needed.
  *
- * Measured on this change: the stack schema's `.d.ts` node was already near
- * that ceiling, and adding `packages`' expanded element type pushed it over.
- * The annotation keeps the declaration one named reference wide.
+ * Element-loose: the two aliases above name every collection KEY (the set is
+ * still derived from `COMPOSE_KEY_DISPOSITIONS`, see `AssembledPackageBodyKey`)
+ * but type each collection as `unknown` rather than mapping
+ * `z.input<(typeof STACK_DEFINITION_COLLECTIONS_SHAPE)[K]>` per key. The mapped
+ * form was tried first and measured on #14513: referencing the shape const from
+ * an EXPORTED type makes the declaration emit write `STACK_DEFINITION_COLLECTIONS_SHAPE`
+ * into `stack.zod-*.d.ts` a second time (21,443 lines beside the 42,449 the
+ * stack schema already occupies), and every consumer program then re-infers all
+ * ~35 collection input/output types once more — the `qa/http-conformance`
+ * type-check-debt re-measure went from green to out-of-memory at the 4096 MB
+ * ceiling `scripts/check-type-check-coverage.mjs` pins as CI's. With the keys
+ * held and the elements `unknown`, nothing here references the shape const, the
+ * second copy is not emitted, and the per-key inference does not run.
+ *
+ * What a consumer loses is only the STATIC element type of a collection inside
+ * an assembled body (`body.objects` is `unknown`, not `ObjectDefinition[]`); the
+ * RUNTIME schema below still carries every collection's full declaration, so a
+ * wrong-shaped body is refused exactly as before. Readers of assembled bodies
+ * (`compile.ts`, `artifact-packages.ts`) already treat them as records and
+ * narrow at the point of use; that is the honest shape for a payload whose
+ * collections are attributed per package only at composition time.
  */
 export const AssembledPackageBodySchema: z.ZodType<AssembledPackageBodyParsed, AssembledPackageBody> =
   lazySchema(() =>