@alloy-js/core 0.23.0-dev.9 → 0.24.0-dev.1

package/temp/api.json

@@ -138,6 +138,448 @@
       "name": "",
       "preserveMemberOrder": false,
       "members": [
+        {
+          "kind": "Interface",
+          "canonicalReference": "@alloy-js/core!AccessExpressionConfig:interface",
+          "docComment": "/**\n * Configuration for creating a language-specific access expression component.\n *\n * @typeParam TPartProps - The Part component's props type (extends BasePartProps)\n *\n * @typeParam TPart - The descriptor type that formatPart receives\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export interface AccessExpressionConfig<TPartProps extends "
+            },
+            {
+              "kind": "Reference",
+              "text": "BasePartProps",
+              "canonicalReference": "@alloy-js/core!BasePartProps:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ", TPart> "
+            }
+          ],
+          "fileUrlPath": "src/components/AccessExpression.tsx",
+          "releaseTag": "Public",
+          "typeParameters": [
+            {
+              "typeParameterName": "TPartProps",
+              "constraintTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "defaultTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              }
+            },
+            {
+              "typeParameterName": "TPart",
+              "constraintTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              },
+              "defaultTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              }
+            }
+          ],
+          "name": "AccessExpressionConfig",
+          "preserveMemberOrder": false,
+          "members": [
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#canUseCallChains:member(1)",
+              "docComment": "/**\n * Additional check for whether call chain formatting should be used.\n * Called only when `isCallPart` is provided and more than one call is detected.\n * Return false to force linear formatting (e.g., TypeScript disables call\n * chains when any part has `await`).\n * Defaults to `() => true`.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "canUseCallChains?(parts: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "parts",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "canUseCallChains"
+            },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#createDescriptor:member(1)",
+              "docComment": "/**\n * Convert Part props + resolved symbol into a plain descriptor object.\n * Called once per Part during children processing. The returned descriptor\n * is wrapped in a computed + getter delegation for reactive optimization.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "createDescriptor(props: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPartProps"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", symbol: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "OutputSymbol",
+                  "canonicalReference": "@alloy-js/core!OutputSymbol:class"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", first: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 8,
+                "endIndex": 9
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "props",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "symbol",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 5
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "first",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 6,
+                    "endIndex": 7
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "createDescriptor"
+            },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#formatPart:member(1)",
+              "docComment": "/**\n * Format a non-first part given its descriptor and the previous part.\n * Returns JSX children for that segment (e.g., `.foo`, `?.bar`, `[idx]`, `(args)`).\n * `inCallChain` is true when rendering inside a chunked call chain.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "formatPart(part: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", prevPart: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", inCallChain: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 7,
+                "endIndex": 8
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "part",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "prevPart",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "inCallChain",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 5,
+                    "endIndex": 6
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "formatPart"
+            },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#getBase:member(1)",
+              "docComment": "/**\n * Extract the base content from the first part (the leftmost identifier).\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "getBase(part: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "part",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "getBase"
+            },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#isCallPart:member(1)",
+              "docComment": "/**\n * Identify which parts are function calls, for call chain detection.\n * When provided, the factory uses the chunked call chain algorithm\n * (line breaks after each call group) when more than one call is detected.\n * When omitted, the expression is always formatted linearly.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "isCallPart?(part: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "part",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "isCallPart"
+            },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig#wrapPartResult:member(1)",
+              "docComment": "/**\n * Post-process the accumulated expression after each part in linear\n * (non-call-chain) mode. Use this for language-specific wrapping like\n * TypeScript's `await` which wraps the entire expression so far.\n * Defaults to identity (returns expression unchanged).\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "wrapPartResult?(expression: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", part: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "TPart"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", index: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", isLast: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Children",
+                  "canonicalReference": "@alloy-js/core!Children:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 9,
+                "endIndex": 10
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "expression",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "part",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 3,
+                    "endIndex": 4
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "index",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 5,
+                    "endIndex": 6
+                  },
+                  "isOptional": false
+                },
+                {
+                  "parameterName": "isLast",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 7,
+                    "endIndex": 8
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "wrapPartResult"
+            }
+          ],
+          "extendsTokenRanges": []
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@alloy-js/core!AlignIntrinsicElement:type",
@@ -854,7 +1296,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!BaseListProps#enderPunctuation:member",
-              "docComment": "/**\n * Place the join punctuation at the end, but without a line break.\n */\n",
+              "docComment": "/**\n * Place the join punctuation at the end, without a line break. The punctuation\n * is emitted unconditionally in flat and broken modes.\n *\n * To add trailing punctuation only in broken mode, use `ender` with `<ifBreak>`\n * inside a `<group>` with a non-hardline joiner (e.g. `line`):\n *\n * ```tsx\n * <group>\n *   <List comma line ender={<ifBreak>,</ifBreak>}>...</List>\n * </group>\n * ```\n *\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1118,6 +1560,80 @@
           ],
           "name": "baseListPropsToMapJoinArgs"
         },
+        {
+          "kind": "Interface",
+          "canonicalReference": "@alloy-js/core!BasePartProps:interface",
+          "docComment": "/**\n * Base props that all language-specific Part components must include.\n * Language packages extend this with additional props.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export interface BasePartProps "
+            }
+          ],
+          "fileUrlPath": "src/components/AccessExpression.tsx",
+          "releaseTag": "Public",
+          "name": "BasePartProps",
+          "preserveMemberOrder": false,
+          "members": [
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/core!BasePartProps#refkey:member",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "refkey?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Refkeyable",
+                  "canonicalReference": "@alloy-js/core!Refkeyable:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "refkey",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/core!BasePartProps#symbol:member",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "symbol?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "OutputSymbol",
+                  "canonicalReference": "@alloy-js/core!OutputSymbol:class"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "symbol",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            }
+          ],
+          "extendsTokenRanges": []
+        },
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/core!BasicScope:class",
@@ -2010,7 +2526,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!Block:function(1)",
-          "docComment": "/**\n * Create an indented block of source text. The block has `opener` text which is\n * added prior to the block, which defaults to `\"{\"`, and `closer` text which is\n * added after the block, which defaults to `\"}\"`.\n */\n",
+          "docComment": "/**\n * Create an indented block of source text. The block has `opener` text which is\n * added prior to the block, which defaults to `\"{\"`, and `closer` text which is\n * added after the block, which defaults to `\"}\"`.\n *\n * @remarks\n *\n *\n *\n * When `children` is empty, `Block` renders as `{}` (opener immediately followed\n * by closer) with no indented content — no explicit empty check is needed before\n * passing children.\n *\n * @example\n * ```tsx\n * // Safe even when props.members is empty — renders `{}`\n * <Block>{props.members}</Block>\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4413,14 +4929,137 @@
                 "startIndex": 1,
                 "endIndex": 2
               }
-            }
-          ],
-          "extendsTokenRanges": [
+            }
+          ],
+          "extendsTokenRanges": [
+            {
+              "startIndex": 1,
+              "endIndex": 2
+            }
+          ]
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/core!createAccessExpression:function(1)",
+          "docComment": "/**\n * Create a language-specific access/member expression component pair.\n *\n * Returns `{ Expression, Part }` where:\n * - `Expression` is the main component that collects Part children and renders the chain\n * - `Part` is a no-op component whose props are consumed by Expression\n *\n * The factory handles:\n * - Children collection and Part filtering\n * - Symbol resolution (refkey → symbol via binder, single computed per part)\n * - Reactive optimization (getter delegation over single computed per part)\n * - Flattening nested Expression instances\n * - `takeSymbols()` to prevent symbol leakage\n * - Call chain detection and chunked formatting algorithm\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function createAccessExpression<TPartProps extends "
+            },
+            {
+              "kind": "Reference",
+              "text": "BasePartProps",
+              "canonicalReference": "@alloy-js/core!BasePartProps:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ", TPart extends "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, unknown>"
+            },
+            {
+              "kind": "Content",
+              "text": ">(config: "
+            },
+            {
+              "kind": "Reference",
+              "text": "AccessExpressionConfig",
+              "canonicalReference": "@alloy-js/core!AccessExpressionConfig:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<TPartProps, TPart>"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    Expression: (props: {\n        children: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Children",
+              "canonicalReference": "@alloy-js/core!Children:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    }) => "
+            },
+            {
+              "kind": "Reference",
+              "text": "Children",
+              "canonicalReference": "@alloy-js/core!Children:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    Part: (_props: TPartProps) => void;\n    registerOuterComponent: (component: "
+            },
+            {
+              "kind": "Reference",
+              "text": "ComponentDefinition",
+              "canonicalReference": "@alloy-js/core!ComponentDefinition:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<any>) => void;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/components/AccessExpression.tsx",
+          "returnTypeTokenRange": {
+            "startIndex": 9,
+            "endIndex": 16
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "config",
+              "parameterTypeTokenRange": {
+                "startIndex": 6,
+                "endIndex": 8
+              },
+              "isOptional": false
+            }
+          ],
+          "typeParameters": [
+            {
+              "typeParameterName": "TPartProps",
+              "constraintTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "defaultTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              }
+            },
             {
-              "startIndex": 1,
-              "endIndex": 2
+              "typeParameterName": "TPart",
+              "constraintTokenRange": {
+                "startIndex": 3,
+                "endIndex": 5
+              },
+              "defaultTypeTokenRange": {
+                "startIndex": 0,
+                "endIndex": 0
+              }
             }
-          ]
+          ],
+          "name": "createAccessExpression"
         },
         {
           "kind": "Function",
@@ -4898,7 +5537,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!createFormatOptionsContextFor:function(1)",
-          "docComment": "/**\n * Create a format options context for a specific file type\n */\n",
+          "docComment": "/**\n * Create a format options context for a specific file type. Returns a\n * `Provider` component and a `useFormatOptions` hook.\n *\n * @remarks\n *\n *\n *\n * Merge precedence: `defaults` (lowest) → Provider `value` → `overrides`\n * argument to `useFormatOptions()` (highest). Undefined override values are\n * ignored.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5261,7 +5900,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!createNamePolicy:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Creates a name policy that transforms symbol names based on element kind.\n *\n * @remarks\n *\n *\n * `element` identifies the kind of declaration (e.g., `\"value\"`, `\"type\"`).\n * The set of valid element strings is defined by the language package.\n *\n * When `element` is `undefined` (outside a declaration context), {@link NamePolicy.getName}\n * and {@link NamePolicy.for} short-circuit and return the original name unchanged — the\n * namer callback is **not** invoked. The namer therefore always receives a defined `T`.\n * This means names outside a declaration context cannot be transformed by the policy.\n *\n * @example\n * ```ts\n * const policy = createNamePolicy((name, element) => {\n *   if (element === \"value\") return toCamelCase(name);\n *   if (element === \"type\")  return toPascalCase(name);\n *   return name;\n * });\n * <Output namePolicy={policy}>...</Output>\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5277,7 +5916,7 @@
             },
             {
               "kind": "Content",
-              "text": "(name: string, elements: T) => string"
+              "text": "(name: string, element: T) => string"
             },
             {
               "kind": "Content",
@@ -5641,7 +6280,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!createScope:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Construct a scope instance and register it with devtools. Prefer this over\n * calling `new` directly so that debugging tools can track the scope.\n *\n * @remarks\n *\n *\n *\n * Inside a component, obtain the current scope with `useScope()` and pass it\n * as the `parentScope` constructor argument so the new scope is wired into\n * the scope tree.\n *\n * @param ctor - The scope subclass constructor.\n *\n * @param args - Positional arguments forwarded directly to the scope\n * constructor; see {@link OutputScope} for the base-class constructor\n * signature.\n *\n * @example\n * ```tsx\n * function MyScope(props) {\n *   const parentScope = useScope();\n *   const scope = createScope(MyScope, \"scope-name\", parentScope);\n *   return <Scope value={scope}>{props.children}</Scope>;\n * }\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -5902,7 +6541,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!createSymbol:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Construct a symbol instance and register it with devtools. Prefer this over\n * calling `new` directly so that debugging tools can track the symbol.\n *\n * @remarks\n *\n *\n *\n * Binder registration (via `useBinder()` + `notifySymbolCreated()`) happens\n * inside the `OutputSymbol` constructor regardless of whether you use\n * `createSymbol` or `new`. This helper only adds devtools registration.\n *\n * @param ctor - The symbol subclass constructor.\n *\n * @param args - Arguments forwarded to the constructor.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -8415,6 +9054,67 @@
             "endIndex": 8
           }
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/core!formatReactivePropertyLabel:function(1)",
+          "docComment": "/**\n * Build a human-readable label for a reactive property like `symbolName.prop`.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function formatReactivePropertyLabel(target: "
+            },
+            {
+              "kind": "Content",
+              "text": "object"
+            },
+            {
+              "kind": "Content",
+              "text": ", key: "
+            },
+            {
+              "kind": "Content",
+              "text": "string | number"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/reactivity.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 5,
+            "endIndex": 6
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "target",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "key",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "formatReactivePropertyLabel"
+        },
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!ForProps:interface",
@@ -11574,7 +12274,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!LibrarySymbolReference:interface",
-          "docComment": "",
+          "docComment": "/**\n * An object that acts as a lazy reference to an external library symbol.\n * Implements {@link REFKEYABLE} and `[TO_SYMBOL]()`.\n *\n * Use {@link isLibrarySymbolReference} to test whether an unknown value is a\n * library symbol reference.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -12634,7 +13334,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!MemberDeclaration:function(1)",
-          "docComment": "/**\n * Declares a symbol in the current member scope for this component's children.\n *\n * @remarks\n *\n *\n *\n * This component must be called in one of two ways: with a name and an optional\n * refkey, or else passing in the symbol. When called with a name and refkey, a\n * symbol will be created in the current scope (provided by\n * {@link MemberDeclarationContext}) with that name and refkey. If a refkey is not\n * provided, `refkey(props.name)` is used.\n *\n * When called with a symbol, that symbol is merely exposed via\n * {@link MemberDeclarationContext}. It is assumed that the caller of this component\n * has created the symbol with the `createSymbol` API on the\n * {@link BinderContext}.\n *\n * @see\n *\n *  {@link BinderContext}\n */\n",
+          "docComment": "/**\n * Declares a symbol in the current member scope for this component's children.\n *\n * @remarks\n *\n *\n *\n * This component must be called in one of two ways: with a name and an optional\n * refkey, or else passing in the symbol. When called with a name and refkey, a\n * `BasicSymbol` will be created in the current member space. When called with a\n * `name`, the owning scope must be a `BasicScope`; for custom scope/symbol\n * types, pass a pre-created `symbol` instead.\n *\n * When called with a symbol, that symbol is merely exposed via\n * {@link MemberDeclarationContext} (not {@link DeclarationContext}). Use\n * {@link MemberName} (not `<Name />`) to render the declared member's name.\n *\n * @see\n *\n *  {@link BinderContext}\n *\n * @see\n *\n *  {@link MemberName}\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -13079,7 +13779,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!MemberName:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Renders the name of the current member declaration from\n * {@link MemberDeclarationContext}. Use this inside a\n * {@link MemberDeclaration} component instead of `<Name />`, which reads from\n * the top-level {@link DeclarationContext}.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -13379,7 +14079,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!MemberResolver:interface",
-          "docComment": "",
+          "docComment": "/**\n * A callback that performs access-control filtering during member resolution.\n *\n * @remarks\n *\n *\n *\n * When provided to {@link ResolveDeclarationByKeyOptions}, it entirely replaces\n * the default checks (ownership assertion and `isMemberSymbol` assertion).\n *\n * **Contract:**\n * - **Return `void`** to accept the member.\n * - **Throw an error** to reject the member — the error propagates to the caller,\n *   matching the behavior of the default checks.\n *\n * @example\n * ```ts\n * const resolver: MemberResolver<MyScope, MySymbol> = (owner, member, ctx) => {\n *   if (member.isPrivate && !ctx.isMemberAccess) {\n *     throw new Error(`${member.name} is not accessible here`);\n *   }\n * };\n * ```\n *\n * @see\n *\n *  {@link MemberResolutionContext} for available context properties.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -13519,7 +14219,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!MemberScope:function(1)",
-          "docComment": "/**\n * Declare a member scope, which is a lexical scope whose symbols are provided\n * by the owner symbol.\n *\n * @remarks\n *\n *\n *\n * This is used to create members of a symbol, e.g. for class members and the\n * like. In some languages, this scope may provide symbols which are can be\n * referenced lexically, but in other languages, these members may not be in\n * scope and instead must be referenced via the owner symbol itself.\n */\n",
+          "docComment": "/**\n * Declare a member scope, which is a lexical scope whose symbols are provided\n * by the owner symbol.\n *\n * @remarks\n *\n *\n *\n * This is used to create members of a symbol, e.g. for class members and the\n * like. In some languages, this scope may provide symbols which are can be\n * referenced lexically, but in other languages, these members may not be in\n * scope and instead must be referenced via the owner symbol itself.\n *\n * When called with `name` (without `value`), this delegates to `<Scope>` which\n * creates a `BasicScope`. The same restriction applies: the parent scope must\n * be a `BasicScope`. For custom scope types, create your scope and pass it via\n * the `value` prop.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -13809,7 +14509,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!memo:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Returns a getter caching the result of `fn`. Re-evaluates when reactive\n * dependencies change. See the [Reactivity docs](../../reactivity.md) for details.\n *\n * @param fn - Function to memoize.\n *\n * @param equal - Skip updates when value is unchanged.\n *\n * @param name - Debug label for traces.\n *\n * @returns  A zero-argument getter returning the cached value.\n *\n * @example\n * ```ts\n * const fullName = memo(() => `${first.value} ${last.value}`);\n * fullName(); // cached; re-evaluates when first or last changes\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -14340,7 +15040,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!NameConflictResolver:interface",
-          "docComment": "",
+          "docComment": "/**\n * A callable interface invoked by the binder when two or more symbols in the\n * same scope share a name. The resolver mutates symbol names to eliminate\n * conflicts (e.g., appending `_2`, `_3`).\n *\n * @remarks\n *\n *\n * The resolver is called with the shared `name` and all symbols in the scope\n * that have that original name. Rename a symbol by assigning to `symbol.name`.\n * Symbols with `ignoreNameConflict: true` are excluded. The default resolver\n * keeps the first symbol unchanged and renames subsequent ones\n * `originalName + \"_2\"`, `originalName + \"_3\"`, etc.\n *\n * Assigned names pass through the active name policy before being stored;\n * design suffixes to produce the correct final name after policy\n * transformation, or set `ignoreNamePolicy` on the symbol after resolution.\n *\n * Conflict detection is keyed on `originalName`\n * (see {@link OutputSymbol.originalName}). Symbols that differ in original\n * name but normalize to the same policy-applied name are never detected as\n * conflicting.\n *\n * @example\n * ```ts\n * const resolver: NameConflictResolver = (name, symbols) => {\n *   for (let i = 1; i < symbols.length; i++) {\n *     symbols[i].name = symbols[i].originalName + \"_\" + (i + 1);\n *   }\n * };\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -14710,7 +15410,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@alloy-js/core!NamePolicy#for:member(1)",
-              "docComment": "/**\n * Get a function that takes a name and applies the naming policy to it.\n */\n",
+              "docComment": "/**\n * Get a function that takes a name and applies the naming policy to it.\n * When `element` is `undefined`, returns an identity function.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -14756,7 +15456,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@alloy-js/core!NamePolicy#getName:member(1)",
-              "docComment": "/**\n * Apply the language policy to the provided name for the provided element\n * type.\n */\n",
+              "docComment": "/**\n * Apply the language policy to the provided name for the provided element type.\n * When `element` is `undefined`, returns `originalName` unchanged.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -14857,7 +15557,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!NamePolicyGetter:interface",
-          "docComment": "",
+          "docComment": "/**\n * A function that transforms a name according to a naming policy for a\n * specific element kind. Obtained from {@link NamePolicy.for}.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -15145,7 +15845,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/core!OutputDeclarationSpace:class",
-          "docComment": "",
+          "docComment": "/**\n * A symbol table attached to an {@link OutputScope}. Holds lexical declarations\n * visible within that scope (e.g., \"types\" or \"values\" in a TypeScript module).\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -15401,7 +16101,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!OutputDirectory#path:member",
-              "docComment": "",
+              "docComment": "/**\n * Full path from the output root, e.g. `\"generated-client/src\"`. Do not prepend parent directory paths when walking the tree.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -15509,7 +16209,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!OutputFileBase#path:member",
-              "docComment": "",
+              "docComment": "/**\n * Full path from the output root, e.g. `\"generated-client/src/models.ext\"`. Do not prepend parent directory paths when walking the tree.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -15539,7 +16239,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/core!OutputMemberSpace:class",
-          "docComment": "",
+          "docComment": "/**\n * A symbol table attached to an {@link OutputSymbol}. Holds member declarations\n * belonging to that symbol (e.g., \"static\" or \"instance\" members of a class).\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -15819,15 +16519,16 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!OutputProps#nameConflictResolver:member",
-              "docComment": "/**\n * Policy for handling multiple symbols declared with the same name.\n */\n",
+              "docComment": "/**\n * Policy for handling multiple symbols declared with the same name.\n *\n * @see\n *\n *  {@link NameConflictResolver}\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
                   "text": "nameConflictResolver?: "
                 },
                 {
-                  "kind": "Content",
-                  "text": "(name: string, symbols: any[]) => void"
+                  "kind": "Reference",
+                  "text": "NameConflictResolver",
+                  "canonicalReference": "@alloy-js/core!NameConflictResolver:interface"
                 },
                 {
                   "kind": "Content",
@@ -15981,7 +16682,7 @@
             {
               "kind": "Constructor",
               "canonicalReference": "@alloy-js/core!OutputScope:constructor(1)",
-              "docComment": "/**\n * Constructs a new instance of the `OutputScope` class\n */\n",
+              "docComment": "/**\n * Subclasses must forward all three positional arguments to `super`. See\n * {@link createScope} for the preferred instantiation path.\n *\n * @param name - A descriptive name for this scope (used in debugging and\n * diagnostics).\n *\n * @param parentScope - The parent scope in the scope tree, or `undefined`\n * for root scopes. Inside a component, obtain this via `useScope()`.\n *\n * @param options - Additional scope options; see {@link OutputScopeOptions}.\n *\n * @example\n * ```ts\n * class MyScope extends OutputScope {\n *   constructor(\n *     name: string,\n *     parent: OutputScope | undefined,\n *     options?: OutputScopeOptions,\n *   ) {\n *     super(name, parent, options);\n *   }\n * }\n *\n * // Inside a component:\n * const scope = createScope(MyScope, \"my-scope\", useScope());\n * ```\n *\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -16165,7 +16866,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/core!OutputScope.declarationSpaces:member",
-              "docComment": "",
+              "docComment": "/**\n * The declaration space keys for this scope type. Subclasses override this\n * to declare which declaration spaces are created on construction (e.g.,\n * `[\"types\", \"values\"]`).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -16434,7 +17135,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/core!OutputScope#spaceFor:member(1)",
-              "docComment": "/**\n * Get the declaration space for the given key.\n */\n",
+              "docComment": "/**\n * Get the declaration space for the given key (e.g., `\"types\"`, `\"values\"`).\n * Returns `undefined` when no space with that key exists on this scope.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -16662,7 +17363,7 @@
         {
           "kind": "TypeAlias",
           "canonicalReference": "@alloy-js/core!OutputSpace:type",
-          "docComment": "",
+          "docComment": "/**\n * A symbol table that belongs to either a scope (declaration space) or a symbol\n * (member space).\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -16698,7 +17399,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/core!OutputSymbol:class",
-          "docComment": "/**\n * An output symbol is a named entity that can be referenced in your output\n * code.\n *\n * @remarks\n *\n *\n *\n * This class is the base implementation of symbol. Most languages will have\n * subtypes that provide additional metadata. Symbols are reactive values, so\n * you can observe changes to their properties in a reactive context.\n */\n",
+          "docComment": "/**\n * An output symbol is a named entity that can be referenced in your output\n * code.\n *\n * @remarks\n *\n *\n *\n * This is an abstract base class. Language packages must subclass it and\n * implement the abstract {@link OutputSymbol.copy | copy()} method, which\n * creates a clone that tracks the original's name and flags.\n *\n * Subtypes typically add language-specific properties (e.g., accessibility,\n * static/abstract flags). Symbols are reactive values, so you can observe\n * changes to their properties in a reactive context.\n *\n * To construct a scopeless external library symbol — one that resolves via\n * refkey but does not appear in any declaration space — pass `undefined` as\n * the `spaces` constructor argument and supply `{ binder }` in `options`.\n * See {@link OutputSymbolOptions} (`binder` option) and {@link TO_SYMBOL}.\n *\n * @example\n *\n *\n *\n * ```ts\n * import { createSymbol, OutputSymbol, OutputSpace } from \"@alloy-js/core\";\n *\n * class MySymbol extends OutputSymbol {\n *   copy() {\n *     // getCopyOptions() already includes binder\n *     const opts = this.getCopyOptions();\n *     const sym = createSymbol(MySymbol, this.name, undefined, opts);\n *     this.initializeCopy(sym);\n *     return sym;\n *   }\n * }\n *\n * // name: string | Namekey; spaces: OutputSpace | OutputSpace[] | undefined; options: OutputSymbolOptions\n * const sym = createSymbol(MySymbol, namekey, scope.symbols, { binder });\n *\n * // Construct a scopeless external library symbol (resolves via refkey only):\n * const extSym = createSymbol(MySymbol, namekey, undefined, { binder });\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -16793,7 +17494,7 @@
             {
               "kind": "Constructor",
               "canonicalReference": "@alloy-js/core!OutputSymbol:constructor(1)",
-              "docComment": "/**\n * Constructs a new instance of the `OutputSymbol` class\n */\n",
+              "docComment": "/**\n * Constructs a new instance of the `OutputSymbol` class\n *\n * @param name - The symbol name, or a {@link Namekey} carrying name and\n * options (e.g., `ignoreNamePolicy`).\n *\n * @param spaces - The declaration or member space(s) this symbol belongs to.\n * Pass `undefined` for scopeless external library symbols (see `binder` option).\n *\n * @param options - Additional symbol options (binder, refkeys, metadata,\n * type, name policy, etc.).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -16944,10 +17645,40 @@
               "isProtected": false,
               "isAbstract": false
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@alloy-js/core!OutputSymbol#canonicalName:member",
+              "docComment": "/**\n * The canonical requested name for this symbol: the result of applying the\n * symbol's name policy to its {@link OutputSymbol.originalName | originalName}, or the original name\n * itself when no policy applies. This is the name the symbol would carry if\n * there were no conflicts, and is stable across the symbol's lifetime (it\n * depends only on the immutable `originalName` and the name policy).\n *\n * Used by {@link SymbolTable} as the grouping key for name-conflict\n * resolution, so that symbols whose original names normalize to the same\n * policy-applied name (e.g. `foo_bar` and `fooBar` under camelCase) are\n * recognized as conflicting.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "get canonicalName(): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "canonicalName",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/core!OutputSymbol#copy:member(1)",
-              "docComment": "/**\n * Makes a copy of this symbol which will update the name and flags\n * of the clone when the original symbol is updated.\n *\n * @remarks\n *\n *\n *\n * This is used to create a symbol that is a copy of this symbol, but\n * with a different scope. Changes to the copy will not affect the\n * original symbol, and changes to the original symbol's name and flags\n * will overwrite the copy's name and flags.\n *\n * @param newScope - The scope to use for the copy.\n */\n",
+              "docComment": "/**\n * Create a clone of this symbol whose name and flags reactively track the\n * original.\n *\n * @remarks\n *\n *\n *\n * Called by `SymbolTable.copyTo` during scope/space transfers.\n * Subclasses implement cloning logic and call `getCopyOptions` for\n * base options and `initializeCopy` to wire up member copying and\n * name tracking.\n *\n * **Space registration contract:** The returned clone must not be registered\n * in any space on exit. `copyToSpace()` calls this method and assigns the\n * space afterward.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -17028,7 +17759,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/core!OutputSymbol#copyToSpace:member(1)",
-              "docComment": "",
+              "docComment": "/**\n * Copy this symbol into the given space. Calls {@link OutputSymbol.copy} and places\n * the result in `space`, then returns the copy.\n *\n * @param space - The space to place the copy in.\n *\n * @returns  The copy of this symbol, now belonging to `space`.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -17142,6 +17873,36 @@
               "isProtected": false,
               "isAbstract": false
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@alloy-js/core!OutputSymbol#deconflictedName:member",
+              "docComment": "/**\n * The name assigned by a name-conflict resolver, or `undefined` when the\n * symbol is not currently renamed by conflict resolution.\n *\n * Resolvers should assign to this slot (rather than `name`) to record that a\n * rename exists only because of a conflict. On re-deconfliction (e.g. after\n * a conflicting symbol is removed), resolvers clear this slot by assigning\n * `undefined`; the effective {@link OutputSymbol.name | name} then falls back to the\n * user-assigned name, which in turn falls back to the original name.\n *\n * Name policy is applied to values written here (unless `ignoreNamePolicy`\n * is true), matching `name`'s behavior.\n *\n *\n * @reactive\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "get deconflictedName(): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string | undefined"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";\n\nset deconflictedName(value: string | undefined);"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "deconflictedName",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/core!OutputSymbol#delete:member(1)",
@@ -17354,7 +18115,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@alloy-js/core!OutputSymbol#initializeCopy:member(1)",
-              "docComment": "",
+              "docComment": "/**\n * Wires up reactive member-space copying and name tracking from this symbol\n * to its `copy`.\n *\n * @remarks\n *\n *\n *\n * Iterates each member space and calls `copyTo` on the corresponding space\n * on `copy`. Then installs a reactive watcher so that any future change to\n * `this.name` is immediately mirrored onto `copy.name`.\n *\n * **Must be called by every `copy()` override** before the override returns.\n * Pair with `getCopyOptions` to supply the base constructor options.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -17641,7 +18402,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/core!OutputSymbol.memberSpaces:member",
-              "docComment": "",
+              "docComment": "/**\n * The member space keys for this symbol type. Subclasses override this to\n * declare which member spaces are created on construction (e.g.,\n * `[\"static\", \"instance\"]`).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -17795,7 +18556,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/core!OutputSymbol#name:member",
-              "docComment": "/**\n * The name of this symbol.\n *\n *\n * @reactive\n */\n",
+              "docComment": "/**\n * The name of this symbol. Assigning to this property applies the active\n * name policy (unless `ignoreNamePolicy` is true) before storing the value.\n *\n * The effective name is computed as `deconflictedName ?? userName`, so if a\n * name-conflict resolver has assigned a {@link OutputSymbol.deconflictedName | deconflictedName}, that value\n * is returned here; otherwise the value most recently assigned to `name` is\n * returned.\n *\n *\n * @reactive\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -18253,7 +19014,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!OutputSymbolOptions#binder:member",
-              "docComment": "/**\n * The binder instance associated with this symbol. Symbol updates and changes\n * will be reported to this binder. This binder will be able to find this\n * symbol via its refkey and other means. Without a binder, this symbol will\n * be unbound, which means it cannot be referenced by refkey.\n */\n",
+              "docComment": "/**\n * The binder instance associated with this symbol. Symbol updates and changes\n * will be reported to this binder. This binder will be able to find this\n * symbol via its refkey and other means. Without a binder, this symbol will\n * be unbound, which means it cannot be referenced by refkey.\n *\n * @remarks\n *\n *\n *\n * When constructing an external library symbol, pass `{ binder }` here to\n * ensure the symbol is registered with the binder. See {@link TO_SYMBOL} for\n * the full implementation protocol.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -18335,7 +19096,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!OutputSymbolOptions#lazyMemberInitializer:member",
-              "docComment": "/**\n * Provide a function which lazy-initializes members when an enumeration of members are needed.\n */\n",
+              "docComment": "/**\n * Provide a function which lazy-initializes members the first time\n * `resolveMemberByName()` is called on this symbol. Called at most once.\n *\n * @remarks\n *\n *\n *\n * Only `resolveMemberByName()` triggers this callback — iterating\n * `OutputMemberSpace` directly does not. The callback fires regardless of\n * whether the symbol belongs to any scope, so it is safe to use on scopeless\n * external library symbols.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -19223,6 +19984,67 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/core!reactivePropertyRefId:function(1)",
+          "docComment": "/**\n * Get a stable ref ID for a property of a reactive object.\n * Each (target, key) pair gets a unique positive ID from the same counter as refs.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function reactivePropertyRefId(target: "
+            },
+            {
+              "kind": "Content",
+              "text": "object"
+            },
+            {
+              "kind": "Content",
+              "text": ", key: "
+            },
+            {
+              "kind": "Content",
+              "text": "string | number"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "number"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/reactivity.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 5,
+            "endIndex": 6
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "target",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "key",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "reactivePropertyRefId"
+        },
         {
           "kind": "Class",
           "canonicalReference": "@alloy-js/core!ReactiveUnionSet:class",
@@ -20406,14 +21228,6 @@
               "kind": "Content",
               "text": "<unknown>"
             },
-            {
-              "kind": "Content",
-              "text": ", isInfrastructure?: "
-            },
-            {
-              "kind": "Content",
-              "text": "boolean"
-            },
             {
               "kind": "Content",
               "text": "): "
@@ -20429,8 +21243,8 @@
           ],
           "fileUrlPath": "src/reactivity.ts",
           "returnTypeTokenRange": {
-            "startIndex": 6,
-            "endIndex": 7
+            "startIndex": 4,
+            "endIndex": 5
           },
           "releaseTag": "Public",
           "overloadIndex": 1,
@@ -20442,14 +21256,6 @@
                 "endIndex": 3
               },
               "isOptional": false
-            },
-            {
-              "parameterName": "isInfrastructure",
-              "parameterTypeTokenRange": {
-                "startIndex": 4,
-                "endIndex": 5
-              },
-              "isOptional": true
             }
           ],
           "name": "refId"
@@ -21036,7 +21842,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!ResolutionResult:interface",
-          "docComment": "/**\n * A successful resolution of a refkey.\n *\n * @example\n *\n *\n *\n * Let's say we have the following scopes and symbols:\n *\n * ```\n * scope: global scope\n * ├── scope: namespace scope 1\n * │   └── symbol: foo\n * │       └── static members\n * │           └── symbol: bar\n * └── scope: namespace scope 2\n *    └── (resolve bar from here)\n * ```\n *\n *\n * When we resolve the refkey for `bar` from within `namespace scope 2`, we will get the following\n * resolution result:\n *\n * * **targetDeclaration**: symbol bar, the symbol we resolved.\n * * **commonScope**: global scope, because this is the most specific scope that contains both the declaration and the reference.\n * * **pathUp**: [namespace scope 2], because this is the scope between the reference and the common scope.\n * * **pathDown**: [namespace scope 1], because this is the scope between the common scope and the declaration\n * * **memberPath**: [foo, bar], because we resolved a member symbol and these are the symbols that lead from the base declaration to the member symbol.\n */\n",
+          "docComment": "/**\n * A successful resolution of a refkey.\n *\n * @example\n *\n *\n *\n * Let's say we have the following scopes and symbols:\n *\n * ```\n * scope: global scope\n * ├── scope: namespace scope 1\n * │   └── symbol: foo\n * │       └── static members\n * │           └── symbol: bar\n * └── scope: namespace scope 2\n *    └── (resolve bar from here)\n * ```\n *\n *\n * When we resolve the refkey for `bar` from within `namespace scope 2`, we will get the following\n * resolution result:\n *\n * * **targetDeclaration**: symbol bar, the symbol we resolved.\n * * **commonScope**: global scope, because this is the most specific scope that contains both the declaration and the reference.\n * * **pathUp**: [namespace scope 2], because this is the scope between the reference and the common scope.\n * * **pathDown**: [namespace scope 1], because this is the scope between the common scope and the declaration\n * * **memberPath**: [bar]\n * * **lexicalDeclaration**: foo\n * For deeper chains (e.g., foo.bar.baz where bar and baz are member symbols, foo is not): memberPath = [bar, baz], lexicalDeclaration = foo.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -21201,7 +22007,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!ResolutionResult#memberPath:member",
-              "docComment": "/**\n * When resolving a member symbol, this is the path of symbols that lead from\n * the lexical declaration to the member symbol.\n */\n",
+              "docComment": "/**\n * Member symbols from the lexical declaration (exclusive) to the resolved symbol\n * (inclusive). Empty when resolving a non-member symbol.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -21809,7 +22615,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!Scope:function(1)",
-          "docComment": "/**\n * Declare a scope for this component's children. Any symbols and scopes\n * declared in the children of this component will be in this scope.\n *\n * @see\n *\n *  {@link ScopeContext}\n */\n",
+          "docComment": "/**\n * Declare a scope for this component's children. Any symbols and scopes\n * declared in the children of this component will be in this scope.\n *\n * @remarks\n *\n *\n *\n * When called with `name` (without `value`), this creates a `BasicScope`. The\n * parent scope must also be a `BasicScope`; for custom scope types, create your\n * scope and pass it via the `value` prop instead.\n *\n * @see\n *\n *  {@link ScopeContext}\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -22217,6 +23023,14 @@
               "kind": "Content",
               "text": "T"
             },
+            {
+              "kind": "Content",
+              "text": ", options?: "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    label?: string;\n}"
+            },
             {
               "kind": "Content",
               "text": "): "
@@ -22237,8 +23051,8 @@
           ],
           "fileUrlPath": "src/reactivity.ts",
           "returnTypeTokenRange": {
-            "startIndex": 3,
-            "endIndex": 5
+            "startIndex": 5,
+            "endIndex": 7
           },
           "releaseTag": "Public",
           "overloadIndex": 1,
@@ -22250,6 +23064,14 @@
                 "endIndex": 2
               },
               "isOptional": true
+            },
+            {
+              "parameterName": "options",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": true
             }
           ],
           "typeParameters": [
@@ -22663,7 +23485,7 @@
         {
           "kind": "Variable",
           "canonicalReference": "@alloy-js/core!SourceDirectoryContext:var",
-          "docComment": "",
+          "docComment": "/**\n * Always provided by `<Output>` — `useContext(SourceDirectoryContext)` is\n * never `undefined` inside an `<Output>` tree. At the root of the tree,\n * `path` equals the `basePath` prop on `<Output>` (default `\"./\"`); nested\n * `<SourceDirectory>` components update `path` relative to their parent.\n *\n * @see\n *\n *  {@link Output}\n *\n * @see\n *\n *  {@link SourceDirectory}\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -23022,7 +23844,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!SourceFileProps#filetype:member",
-              "docComment": "/**\n * The type of contents in this file.\n */\n",
+              "docComment": "/**\n * The type of contents in this file.\n *\n * @remarks\n *\n *\n * This is a metadata hint only. It does not trigger formatting or content\n * processing. The value is forwarded to debug tooling and the\n * `ContentOutputFile` output metadata.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -23049,7 +23871,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/core!SourceFileProps#header:member",
-              "docComment": "/**\n * The header of the file. This is rendered before the contents of the file.\n * This is useful for adding license headers or other metadata to the file.\n */\n",
+              "docComment": "/**\n * Content rendered before the file body, separated from it by a hard line\n * break. The separator is emitted whenever `header` is not `undefined` —\n * including when it is an empty string or a component that renders nothing.\n * To suppress both the header and the separator, omit this prop entirely.\n *\n * @example\n * ```tsx\n * // Omitting `header` suppresses both header and separator:\n * <SourceFile filetype=\"txt\" path=\"output/data.txt\">\n *   {children}\n * </SourceFile>\n *\n * // An empty string still emits the separator newline:\n * <SourceFile filetype=\"txt\" path=\"output/data.txt\" header=\"\">\n *   {children}\n * </SourceFile>\n * ```\n *\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -24278,7 +25100,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@alloy-js/core!SymbolCreator:interface",
-          "docComment": "",
+          "docComment": "/**\n * An object that can register symbols into a binder. Pass instances to the\n * `externals` prop of `<Output>` to make library symbols resolvable.\n *\n * @remarks\n *\n *\n * `SymbolCreator` is a low-level core mechanism for eager symbol registration.\n * The recommended pattern for language packages is lazy self-registration:\n * implement `[TO_SYMBOL]()` on descriptors to call `useBinder()`, create and\n * cache symbols per binder via a `WeakMap`, and register them into the\n * appropriate scope automatically. This approach does not require `externals`.\n * See the C# package's `createLibrary()` for a reference implementation.\n *\n * See {@link TO_SYMBOL} and {@link REFKEYABLE}.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -26108,7 +26930,7 @@
         {
           "kind": "Variable",
           "canonicalReference": "@alloy-js/core!TO_SYMBOL:var",
-          "docComment": "",
+          "docComment": "/**\n * Well-known symbol for the lazy-symbol-creation protocol used by external\n * library descriptors. Objects implementing `[TO_SYMBOL]()` are recognized as\n * {@link LibrarySymbolReference} values that can be passed anywhere a refkey\n * is accepted.\n *\n * @remarks\n *\n *\n *\n * Implement `[TO_SYMBOL]()` on a descriptor object to register it as a\n * referenceable library symbol. Inside the method:\n *\n * 1. Call {@link useBinder} to get the current binder context.\n * 2. Look up (or create) the symbol for that binder in a\n *    `WeakMap<object, OutputSymbol>` (use a sentinel object for the\n *    no-binder case, since `WeakMap` keys must be objects).\n * 3. On first creation, construct the symbol and register it into the\n *    appropriate space for your library, passing `{ binder }`\n *    (see {@link OutputSymbolOptions.binder}).\n *\n * The method is called by language package code each time the descriptor is\n * used as a reference (e.g. inside `ref()`). It is NOT called by the binder\n * itself.\n *\n * @example\n *\n *\n *\n * ```ts\n * const defaultKey = {};\n * const symbols = new WeakMap<object, MySymbol>();\n * const descriptor: LibrarySymbolReference = {\n *   [REFKEYABLE]() {\n *     return descriptor[TO_SYMBOL]().refkeys[0];\n *   },\n *   [TO_SYMBOL]() {\n *     const binder = useBinder();\n *     const key = binder ?? defaultKey;\n *     let sym = symbols.get(key);\n *     if (!sym) {\n *       sym = new MySymbol(\"SomeType\", space, { binder });\n *       symbols.set(key, sym);\n *     }\n *     return sym;\n *   },\n * };\n * ```\n *\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -26726,7 +27548,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!useBinder:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Returns the current {@link Binder} from context, or `undefined` if no\n * binder is available. The binder is provided by the {@link Output} component.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -27006,7 +27828,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!useScope:function(1)",
-          "docComment": "",
+          "docComment": "/**\n * Returns the current {@link OutputScope} from context. Must be called inside\n * a component that is a descendant of a `<Scope>` provider.\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",