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

package/docs/api/types/NamePolicy.md

@@ -0,0 +1,8 @@
+# NamePolicy
+
+## Members
+
+|         |                                                                   |                                                                                                                                                |
+| ------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| for     | (element: TElements \| undefined) => NamePolicyGetter             | Get a function that takes a name and applies the naming policy to it. When `element` is `undefined`, returns an identity function.             |
+| getName | (originalName: string, element: TElements \| undefined) => string | Apply the language policy to the provided name for the provided element type. When `element` is `undefined`, returns `originalName` unchanged. |

package/docs/api/types/NamePolicyGetter.md

@@ -0,0 +1,9 @@
+# NamePolicyGetter
+
+A function that transforms a name according to a naming policy for a specific element kind. Obtained from \[unresolved link].
+
+## Members
+
+|                |                                  |   |
+| -------------- | -------------------------------- | - |
+| Call signature | (originalName: string) => string |   |

package/docs/api/types/Namekey.md

@@ -0,0 +1,10 @@
+# Namekey
+
+## Members
+
+Extends [SymbolRefkey](../symbolrefkey/)
+
+|         |          |   |
+| ------- | -------- | - |
+| name    | string   |   |
+| options | TOptions |   |

package/docs/api/types/NamekeyOptions.md

@@ -0,0 +1,8 @@
+# NamekeyOptions
+
+## Members
+
+|                    |                  |   |
+| ------------------ | ---------------- | - |
+| ignoreNameConflict | optional boolean |   |
+| ignoreNamePolicy   | optional boolean |   |

package/docs/api/types/OnReactiveSetAddCallback.md

@@ -0,0 +1,5 @@
+# OnReactiveSetAddCallback
+
+```ts
+type OnReactiveSetAddCallback<T> = (value: T) => T;
+```

package/docs/api/types/OnReactiveSetDeleteCallback.md

@@ -0,0 +1,5 @@
+# OnReactiveSetDeleteCallback
+
+```ts
+type OnReactiveSetDeleteCallback<T> = (value: T) => void;
+```

package/docs/api/types/OutputDeclarationSpace.md

@@ -0,0 +1,13 @@
+# OutputDeclarationSpace
+
+A symbol table attached to an [OutputScope](../outputscope/). Holds lexical declarations visible within that scope (e.g., “types” or “values” in a TypeScript module).
+
+## Members
+
+Extends [SymbolTable](../symboltable/)
+
+|                   |                                                   |                                                                 |
+| ----------------- | ------------------------------------------------- | --------------------------------------------------------------- |
+| \[inspect.custom] | () => string                                      |                                                                 |
+| constructor       | (scope: OutputScope, key: string, binder: Binder) | Constructs a new instance of the [`OutputDeclarationSpace`](OutputDeclarationSpace.md) class |
+| scope             | [OutputScope](../outputscope/)                    | The scope this declaration space belongs to.                    |

package/docs/api/types/OutputDirectory.md

@@ -0,0 +1,59 @@
+# OutputDirectory
+
+Turning components into source text involves three different trees produced sequentially:
+
+1. Component tree, built by the nesting of components
+2. Rendered text tree, produced by *rendering* the component tree
+3. Document tree, produced by *printing* the rendered text tree
+
+Finally, the document tree is converted to text via `prettier`. Let’s look at each of these trees and the conversions in detail.
+
+# Component tree
+
+The component tree is built by JSX or STC templates. The nodes in this tree are defined by the type [`Child`](Child.md) and are one of the following
+
+## Primitive values
+
+Strings in the tree are placed into the rendered text tree as-is. Numbers are converted to strings. Falsy primitive values and booleans are converted to empty strings (and may cause a line break to be ignored, see below).
+
+## Nullary functions
+
+Nullary functions represent computed or reactive values in the component tree, such as expressions placed into a JSX template with curly brackets. Nullary functions return [`Children`](Children.md) which are then recursively rendered. Nullary functions are invoked in an effect which will update the rendered text tree when any reactive dependencies change.
+
+## Component creators
+
+Component creators are a special kind of nullary function which instantiate components in order to get their children which are then recursively rendered. Component creators have some special rendering behavior, such as tracking the stack of rendered components. Like other nullary functions, component creators are invoked in an effect which will update the rendered text tree when any reactive dependencies change.
+
+## Refs
+
+Refs are wrapped in a nullary function and rendered in an effect which will update the rendered text tree when the ref’s value changes. This is essentially a syntactic convenience, allowing JSX templates to contain `\{ someRef \}` instead of `\{ someRef.value \}`.
+
+## Refkey
+
+Refkeys are replaced with a component creator for the Reference component associated with the current source file. This allows creating references by placing them directly in the component tree e.g. `{ someRefkey }`.
+
+## CustomContext
+
+CustomContext is a special kind of component which allows rendering children within a custom reactive context. This enables components to manually manage the lifetime of their reactive contexts.
+
+## IntrinsicElement
+
+Various intrinsic elements exist to control formatting. These elements provide Print Hooks that are called during Printing.
+
+# Rendered Text Tree
+
+This tree is a nested array structure containing the rendered output of all the components in the component tree. This structure is updated reactively when reactive dependencies change. The nodes in this tree are predominantly strings, but can also be Print Hooks.
+
+This tree is built by the `renderTree` function.
+
+# Document Tree
+
+This tree is constructed by calling `printTree` on the rendered text tree. The rendered text tree is walked and the appropriate Prettier builders are called to produce a document tree. The result is then passed to Prettier’s `printDocToString` function to produce the final source text.
+
+## Members
+
+|          |                                                                             |                                                                                                                             |
+| -------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| contents | ([OutputDirectory](../outputdirectory/) \| [OutputFile](../outputfile/))\[] |                                                                                                                             |
+| kind     | ”directory”                                                                 |                                                                                                                             |
+| path     | string                                                                      | Full path from the output root, e.g. `"generated-client/src"`. Do not prepend parent directory paths when walking the tree. |

package/docs/api/types/OutputFile.md

@@ -0,0 +1,5 @@
+# OutputFile
+
+```ts
+type OutputFile = ContentOutputFile | CopyOutputFile;
+```

package/docs/api/types/OutputFileBase.md

@@ -0,0 +1,8 @@
+# OutputFileBase
+
+## Members
+
+|      |        |                                                                                                                                        |
+| ---- | ------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| kind | ”file” |                                                                                                                                        |
+| path | string | Full path from the output root, e.g. `"generated-client/src/models.ext"`. Do not prepend parent directory paths when walking the tree. |

package/docs/api/types/OutputMemberSpace.md

@@ -0,0 +1,13 @@
+# OutputMemberSpace
+
+A symbol table attached to an [OutputSymbol](../outputsymbol/). Holds member declarations belonging to that symbol (e.g., “static” or “instance” members of a class).
+
+## Members
+
+Extends [SymbolTable](../symboltable/)
+
+|                   |                                                     |                                                            |
+| ----------------- | --------------------------------------------------- | ---------------------------------------------------------- |
+| \[inspect.custom] | () => string                                        |                                                            |
+| constructor       | (symbol: OutputSymbol, key: string, binder: Binder) | Constructs a new instance of the [`OutputMemberSpace`](OutputMemberSpace.md) class |
+| symbol            | [OutputSymbol](../outputsymbol/)                    | The symbol this member space belongs to.                   |

package/docs/api/types/OutputScope.md

@@ -0,0 +1,33 @@
+# OutputScope
+
+A container of symbols accessible within some scope in your output code.
+
+## Members
+
+|                   |                                                                                    |                                                                                                                                                                                                              |
+| ----------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| \_\_v\_skip       | boolean                                                                            |                                                                                                                                                                                                              |
+| \[inspect.custom] | () => string                                                                       |                                                                                                                                                                                                              |
+| constructor       | (name: string, parentScope: OutputScope \| undefined, options: OutputScopeOptions) | Subclasses must forward all three positional arguments to `super`. See [createScope](../../functions/createscope/) for the preferred instantiation path.                                                     |
+| binder            | [Binder](../binder/) \| undefined                                                  | The binder that created this scope.                                                                                                                                                                          |
+| children          | Set<[OutputScope](../outputscope/)>                                                | The scopes nested within this scope.                                                                                                                                                                         |
+| debugInfo         | Record\<string, unknown>                                                           |                                                                                                                                                                                                              |
+| declarationSpaces | Readonly\<string\[]>                                                               | The declaration space keys for this scope type. Subclasses override this to declare which declaration spaces are created on construction (e.g., `["types", "values"]`).                                      |
+| id                | number                                                                             | The unique id of this scope.                                                                                                                                                                                 |
+| isMemberScope     | boolean                                                                            | Check if this is scope is a member scope. Member scopes have no member spaces of their own, but instead put members of their owner symbol in scope.                                                          |
+| isTransient       | boolean                                                                            | Whether this scope is a transient scope. Transient scopes are used for temporary values that are to be combined with other non-transient symbols. Scopes are transient when their owner symbol is transient. |
+| metadata          | Record\<string, unknown>                                                           | Arbitrary metadata associated with this scope. This property is not reactive but the metadata object is a reactive object.                                                                                   |
+| name              | string                                                                             | The name of the scope.                                                                                                                                                                                       |
+| ownerSymbol       | [OutputSymbol](../outputsymbol/) \| undefined                                      | The symbol whose members are in scope. When an owner symbol is present, this scope is considered a member scope, and does not provide its own declaration spaces.                                            |
+| parent            | [OutputScope](../outputscope/) \| undefined                                        | The parent scope of this scope. Undefined if this is a root scope.                                                                                                                                           |
+| spaceFor          | (key: string) => OutputSpace \| undefined                                          | Get the declaration space for the given key (e.g., `"types"`, `"values"`). Returns `undefined` when no space with that key exists on this scope.                                                             |
+| spaces            | [OutputDeclarationSpace](../outputdeclarationspace/)\[]                            | Get all the declaration spaces in this scope.                                                                                                                                                                |
+| toString          | () => string                                                                       |                                                                                                                                                                                                              |
+
+## Remarks
+
+Scopes form a tree. All scopes except the global scope have a parent scope identified by `parent`. Scopes can have nested scopes which can be accessed using the `children` property. Whether a child scope can be accessed from the parent scope is determined by each language’s scoping rules.
+
+This interface is the base implementation of scope. Generally, most languages will have subtypes of this interface that provide additional metadata about the scope. For example, TypeScript scopes need to track whether the scope represents a package, module, class, function, etc.
+
+Scopes are reactive values, which allows you to observe changes to the scope within a reactive context.

package/docs/api/types/OutputScopeOptions.md

@@ -0,0 +1,9 @@
+# OutputScopeOptions
+
+## Members
+
+|             |                                           |                                                                                                                                                                               |
+| ----------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| binder      | optional [Binder](../binder/)             | The binder instance this scope belongs to. If not provided, it will attempt to find the current binder from context.                                                          |
+| metadata    | optional Record\<string, unknown>         | Arbitrary metadata that is associated with this scope.                                                                                                                        |
+| ownerSymbol | optional [OutputSymbol](../outputsymbol/) | The owner symbol of this scope. When provided, this scope becomes a member scope, which exposes the symbols on its owner symbol instead of having its own declaration spaces. |

package/docs/api/types/OutputSpace.md

@@ -0,0 +1,7 @@
+# OutputSpace
+
+A symbol table that belongs to either a scope (declaration space) or a symbol (member space).
+
+```ts
+type OutputSpace = OutputDeclarationSpace | OutputMemberSpace;
+```

package/docs/api/types/OutputSymbol.md

@@ -0,0 +1,78 @@
+# OutputSymbol
+
+An output symbol is a named entity that can be referenced in your output code.
+
+## Members
+
+|                          |                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \_\_v\_skip              | boolean                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| \[inspect.custom]        | () => string                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| constructor              | (name: string \| Namekey, spaces: OutputSpace\[] \| OutputSpace \| undefined, options: OutputSymbolOptions)                            | Constructs a new instance of the [`OutputSymbol`](OutputSymbol.md) class                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| aliasTarget              | [OutputSymbol](../outputsymbol/) \| undefined                                                                                          | The symbol that this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| binder                   | [Binder](../binder/) \| undefined                                                                                                      | The binder that is tracking this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| canonicalName            | string                                                                                                                                 | The canonical requested name for this symbol: the result of applying the symbol’s name policy to its originalName, or the original name itself when no policy applies. This is the name the symbol would carry if there were no conflicts, and is stable across the symbol’s lifetime (it depends only on the immutable `originalName` and the name policy). Used by [SymbolTable](../symboltable/) as the grouping key for name-conflict resolution, so that symbols whose original names normalize to the same policy-applied name (e.g. `foo_bar` and `fooBar` under camelCase) are recognized as conflicting. |
+| copy                     | () => OutputSymbol                                                                                                                     | Create a clone of this symbol whose name and flags reactively track the original.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| copyMembersTo            | (targetSymbol: OutputSymbol) => void                                                                                                   | Copy the members of this symbol to the target symbol. This is reactive - whenever a member is added to this symbol, it will be copied to the target symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| copyToSpace              | (space: OutputSpace) => OutputSymbol                                                                                                   | Copy this symbol into the given space. Calls \[unresolved link] and places the result in `space`, then returns the copy.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| dealias                  | () => OutputSymbol                                                                                                                     | If this symbol is an alias for another symbol, return the the aliased symbol. Otherwise, return this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| debugInfo                | Record\<string, unknown>                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| deconflictedName         | string \| undefined                                                                                                                    | The name assigned by a name-conflict resolver, or `undefined` when the symbol is not currently renamed by conflict resolution. Resolvers should assign to this slot (rather than `name`) to record that a rename exists only because of a conflict. On re-deconfliction (e.g. after a conflicting symbol is removed), resolvers clear this slot by assigning `undefined`; the effective name then falls back to the user-assigned name, which in turn falls back to the original name. Name policy is applied to values written here (unless `ignoreNamePolicy` is true), matching `name`‘s behavior.             |
+| delete                   | () => void                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| protected getCopyOptions | () => { binder: Binder \| undefined; aliasTarget: OutputSymbol \| undefined; metadata: Record\<string, unknown>; transient: boolean; } |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| hasTypeSymbol            | boolean                                                                                                                                | Whether this symbol has its symbol representing its type available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| id                       | number                                                                                                                                 | The unique id of this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ignoreNameConflict       | boolean                                                                                                                                | Whether the name of this symbol bypasses the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                                                                                                                                       |
+| ignoreNamePolicy         | boolean                                                                                                                                | Whether the name of this symbol bypasses the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                                                                                                                             |
+| protected initializeCopy | (copy: OutputSymbol) => void                                                                                                           | Wires up reactive member-space copying and name tracking from this symbol to its `copy`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| isAlias                  | boolean                                                                                                                                | Whether this symbol is an alias for another symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| isMemberSymbol           | boolean                                                                                                                                | Whether this symbol is a member of another symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| isMoved                  | boolean                                                                                                                                | Whether this symbol’s members have been moved to another symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| isTransient              | boolean                                                                                                                                | Whether this symbol is a transient symbol. Transient symbols cannot be referenced and are meant to be combined with other symbols.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| isTyped                  | boolean                                                                                                                                | Whether this symbol’s members are provided by a type symbol. The `typeSymbol` property is this symbol. It may not be available yet, so check `hasTypeSymbol`.                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| memberSpaceFor           | (spaceKey: string) => OutputMemberSpace \| undefined                                                                                   | Get the member space for the given key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| memberSpaces             | [OutputMemberSpace](../outputmemberspace/)\[]                                                                                          | The member spaces of this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| memberSpaces             | Readonly\<string\[]>                                                                                                                   | The member space keys for this symbol type. Subclasses override this to declare which member spaces are created on construction (e.g., `["static", "instance"]`).                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| metadata                 | Record\<string, unknown>                                                                                                               | An arbitrary bag of metadata for this symbol. This property is read only, but the metadata is a reactive object.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| movedTo                  | [OutputSymbol](../outputsymbol/) \| undefined                                                                                          | The symbol that this symbol’s members have been moved to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| moveMembersTo            | (targetSymbol: OutputSymbol) => void                                                                                                   | Move member symbols from this transient symbol to the target symbol. This is reactive - whenever a member is added to this symbol, it will be moved to the target symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| name                     | string                                                                                                                                 | The name of this symbol. Assigning to this property applies the active name policy (unless `ignoreNamePolicy` is true) before storing the value. The effective name is computed as `deconflictedName ?? userName`, so if a name-conflict resolver has assigned a deconflictedName, that value is returned here; otherwise the value most recently assigned to `name` is returned.                                                                                                                                                                                                                                 |
+| namePolicy               | [NamePolicyGetter](../namepolicygetter/) \| undefined                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| originalName             | string                                                                                                                                 | Read only. The requested name of this symbol. The symbol’s actual name may be different depending on naming policy or conflicts with other symbols.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| ownerSymbol              | [OutputSymbol](../outputsymbol/) \| undefined                                                                                          | When this is a member symbol, this returns the symbol that this is symbol is a member of.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| refkeys                  | [Refkey](../refkey/)\[]                                                                                                                | The refkeys for this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| resolveMemberByName      | (name: string) => OutputSymbol \| undefined                                                                                            | Get a member symbol by name from this symbol’s member spaces. Checks member spaces in order until it finds a member with that name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| scope                    | import(”./output-scope.js”).[OutputScope](../outputscope/) \| undefined                                                                | The scope this symbol is in. When this symbol is a member symbol, this will return undefined.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| spaces                   | [OutputSpace](../outputspace/)\[]                                                                                                      | The declaration or member spaces this symbol belongs to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| toString                 | () => string                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| type                     | [OutputSymbol](../outputsymbol/) \| undefined                                                                                          | The symbol which defines the type of this symbol. The type symbol provides information about the value this symbol contains, such as what members it has.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+
+## Remarks
+
+This is an abstract base class. Language packages must subclass it and implement the abstract copy() method, which creates a clone that tracks the original’s name and flags.
+
+Subtypes typically add language-specific properties (e.g., accessibility, static/abstract flags). Symbols are reactive values, so you can observe changes to their properties in a reactive context.
+
+To construct a scopeless external library symbol — one that resolves via refkey but does not appear in any declaration space — pass `undefined` as the `spaces` constructor argument and supply `{ binder }` in `options`. See [OutputSymbolOptions](../outputsymboloptions/) (`binder` option) and [TO\_SYMBOL](../../variables/to_symbol/).
+
+## Example
+
+```ts
+import { createSymbol, OutputSymbol, OutputSpace } from "@alloy-js/core";
+
+class MySymbol extends OutputSymbol {
+  copy() {
+    // getCopyOptions() already includes binder
+    const opts = this.getCopyOptions();
+    const sym = createSymbol(MySymbol, this.name, undefined, opts);
+    this.initializeCopy(sym);
+    return sym;
+  }
+}
+
+// name: string | Namekey; spaces: OutputSpace | OutputSpace[] | undefined; options: OutputSymbolOptions
+const sym = createSymbol(MySymbol, namekey, scope.symbols, { binder });
+
+// Construct a scopeless external library symbol (resolves via refkey only):
+const extSym = createSymbol(MySymbol, namekey, undefined, { binder });
+```

package/docs/api/types/OutputSymbolOptions.md

@@ -0,0 +1,16 @@
+# OutputSymbolOptions
+
+## Members
+
+|                       |                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| aliasTarget           | optional [OutputSymbol](../outputsymbol/)                                                       | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| binder                | optional [Binder](../binder/)                                                                   | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                    |
+| ignoreNamePolicy      | optional boolean                                                                                | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                          |
+| lazyMemberInitializer | optional () => void                                                                             | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating [`OutputMemberSpace`](OutputMemberSpace.md) directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                |
+| metadata              | optional Record\<string, unknown>                                                               | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| namePolicy            | optional [NamePolicyGetter](../namepolicygetter/)                                               | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| refkeys               | optional [Refkey](../refkey/) \| [Refkey](../refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| transient             | optional boolean                                                                                | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| type                  | optional [OutputSymbol](../outputsymbol/) \| Ref<[OutputSymbol](../outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                          |

package/docs/api/types/OutputVisitor.md

@@ -0,0 +1,10 @@
+# OutputVisitor
+
+A visitor to collect the output from [render](../../functions/render/). Used by [traverseOutput](../../functions/traverseoutput/).
+
+## Members
+
+|                |                                      |   |
+| -------------- | ------------------------------------ | - |
+| visitDirectory | (directory: OutputDirectory) => void |   |
+| visitFile      | (file: OutputFile) => void           |   |

package/docs/api/types/PrintHook.md

@@ -0,0 +1,10 @@
+# PrintHook
+
+## Members
+
+|                 |                                                                                                                  |   |
+| --------------- | ---------------------------------------------------------------------------------------------------------------- | - |
+| \[printHookTag] | true                                                                                                             |   |
+| print           | (tree: RenderedTextTree, print: (subtree: RenderedTextTree) => import(“prettier”).Doc) => import(“prettier”).Doc |   |
+| subtree         | [RenderedTextTree](../renderedtexttree/)                                                                         |   |
+| transform       | (tree: RenderedTextTree) => RenderedTextTree                                                                     |   |

package/docs/api/types/PrintTreeOptions.md

@@ -0,0 +1,11 @@
+# PrintTreeOptions
+
+## Members
+
+|                    |                  |                                                                                |
+| ------------------ | ---------------- | ------------------------------------------------------------------------------ |
+| insertFinalNewLine | optional boolean | If files should end with a final new line.                                     |
+| noFlush            | optional boolean | Skip flushing scheduled jobs before printing.                                  |
+| printWidth         | optional number  | The number of characters the printer will wrap on. Defaults to 100 characters. |
+| tabWidth           | optional number  | The number of spaces to use for indentation. Defaults to 2 spaces.             |
+| useTabs            | optional boolean | Whether to use tabs instead of spaces for indentation. Defaults to false.      |

package/docs/api/types/Props.md

@@ -0,0 +1,5 @@
+# Props
+
+```ts
+type Props = Record<string, any>;
+```

package/docs/api/types/ReactiveUnionSet.md

@@ -0,0 +1,20 @@
+# ReactiveUnionSet
+
+## Members
+
+Extends Set\<T>
+
+|                    |                                                                                                     |                                                           |
+| ------------------ | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
+| \_\_v\_isReactive  | boolean                                                                                             |                                                           |
+| \[Symbol.iterator] | () => SetIterator\<T>                                                                               |                                                           |
+| constructor        | (options: ReactiveUnionSetOptions\<T>)                                                              | Constructs a new instance of the [`ReactiveUnionSet`](ReactiveUnionSet.md) class |
+| add                | (item: T) => this                                                                                   |                                                           |
+| addSubset          | (subset: Set\<T>, options: ReactiveUnionSetOptions\<T>) => void                                     |                                                           |
+| createDerivedSet   | (mapper: (value: T) => U \| U\[]) => Readonly\<import(“@vue/reactivity”).ShallowReactive\<Set\<U>>> |                                                           |
+| createIndex        | (mapper: (value: T) => U \| U\[]) => ReadonlyMap\<U, T>                                             |                                                           |
+| delete             | (item: T) => boolean                                                                                |                                                           |
+| entries            | () => SetIterator<\[T, T]>                                                                          |                                                           |
+| keys               | () => SetIterator\<T>                                                                               |                                                           |
+| size               | number                                                                                              |                                                           |
+| values             | () => SetIterator\<T>                                                                               |                                                           |

package/docs/api/types/ReactiveUnionSetOptions.md

@@ -0,0 +1,8 @@
+# ReactiveUnionSetOptions
+
+## Members
+
+|          |                                                                             |   |
+| -------- | --------------------------------------------------------------------------- | - |
+| onAdd    | optional [OnReactiveSetAddCallback](../onreactivesetaddcallback/)\<T>       |   |
+| onDelete | optional [OnReactiveSetDeleteCallback](../onreactivesetdeletecallback/)\<T> |   |

package/docs/api/types/Refkey.md

@@ -0,0 +1,5 @@
+# Refkey
+
+```ts
+type Refkey = SymbolRefkey | MemberRefkey | Namekey;
+```

package/docs/api/types/Refkeyable.md

@@ -0,0 +1,5 @@
+# Refkeyable
+
+```ts
+type Refkeyable = RefkeyableObject | Refkey;
+```

package/docs/api/types/RefkeyableObject.md

@@ -0,0 +1,7 @@
+# RefkeyableObject
+
+```ts
+type RefkeyableObject = {
+    [REFKEYABLE](): Refkey;
+};
+```

package/docs/api/types/RenderableObject.md

@@ -0,0 +1,9 @@
+# RenderableObject
+
+A renderable object is any object that has an `[ay.RENDERABLE]` method that returns children. This is used to allow custom object types to be used as children in Alloy components.
+
+## Members
+
+|               |                |                                  |
+| ------------- | -------------- | -------------------------------- |
+| \[RENDERABLE] | () => Children | Renders this object to children. |

package/docs/api/types/RenderedTextTree.md

@@ -0,0 +1,5 @@
+# RenderedTextTree
+
+```ts
+type RenderedTextTree = (string | RenderedTextTree | PrintHook)[];
+```

package/docs/api/types/ResolutionResult.md

@@ -0,0 +1,39 @@
+# ResolutionResult
+
+A successful resolution of a refkey.
+
+## Members
+
+|                    |                     |                                                                                                                                                                                                                                                                           |
+| ------------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| commonScope        | TScope \| undefined | The lexical scope which contains both the reference and the lexical declaration. Undefined when they do not share a common scope.                                                                                                                                         |
+| fullReferencePath  | TScope\[]           | The scopes from the root to the scope of the reference.                                                                                                                                                                                                                   |
+| fullSymbolPath     | TScope\[]           | The scopes from the root to scope of the lexical declaration.                                                                                                                                                                                                             |
+| lexicalDeclaration | TSymbol             | When the symbol is a member symbol, this is the symbol of the lexical declaration which contains this member symbol, either as one of its own member symbols, or as a member of one of its members. When the symbol is a non-member symbol, this is the same as `symbol`. |
+| memberPath         | TSymbol\[]          | Member symbols from the lexical declaration (exclusive) to the resolved symbol (inclusive). Empty when resolving a non-member symbol.                                                                                                                                     |
+| pathDown           | TScope\[]           | The scopes between the common scope and the declaration.                                                                                                                                                                                                                  |
+| pathUp             | TScope\[]           | The scopes between the common scope and the reference.                                                                                                                                                                                                                    |
+| symbol             | TSymbol             | The resolved symbol. May be declared in a lexical scope or be a member symbol.                                                                                                                                                                                            |
+
+## Example
+
+Let’s say we have the following scopes and symbols:
+
+```
+scope: global scope
+├── scope: namespace scope 1
+│   └── symbol: foo
+│       └── static members
+│           └── symbol: bar
+└── scope: namespace scope 2
+   └── (resolve bar from here)
+```
+
+When we resolve the refkey for `bar` from within `namespace scope 2`, we will get the following resolution result:
+
+* **targetDeclaration**: symbol bar, the symbol we resolved.
+* **commonScope**: global scope, because this is the most specific scope that contains both the declaration and the reference.
+* **pathUp**: \[namespace scope 2], because this is the scope between the reference and the common scope.
+* **pathDown**: \[namespace scope 1], because this is the scope between the common scope and the declaration
+* **memberPath**: \[bar]
+* **lexicalDeclaration**: foo For deeper chains (e.g., foo.bar.baz where bar and baz are member symbols, foo is not): memberPath = \[bar, baz], lexicalDeclaration = foo.

package/docs/api/types/ResolveDeclarationByKeyOptions.md

@@ -0,0 +1,7 @@
+# ResolveDeclarationByKeyOptions
+
+## Members
+
+|                |                                                                 |   |
+| -------------- | --------------------------------------------------------------- | - |
+| memberResolver | optional [MemberResolver](../memberresolver/)\<TScope, TSymbol> |   |

package/docs/api/types/Resource.md

@@ -0,0 +1,11 @@
+# Resource
+
+Represents an external resource fetched asynchronously.
+
+## Members
+
+|         |               |                                                                                            |
+| ------- | ------------- | ------------------------------------------------------------------------------------------ |
+| data    | T \| null     | The data if it’s been loaded successfully. Null when not yet loaded or there was an error. |
+| error   | null \| Error | The error loading the resource, if any.                                                    |
+| loading | boolean       | Whether the resource is still being fetched.                                               |

package/docs/api/types/RootOptions.md

@@ -0,0 +1,7 @@
+# RootOptions
+
+## Members
+
+|                |                                                         |   |
+| -------------- | ------------------------------------------------------- | - |
+| componentOwner | optional [ComponentCreator](../componentcreator/)\<any> |   |

package/docs/api/types/SbrIntrinsicElement.md

@@ -0,0 +1,5 @@
+# SbrIntrinsicElement
+
+```ts
+type SbrIntrinsicElement = IntrinsicElementBase<"sbr">;
+```

package/docs/api/types/ScopeProps.md

@@ -0,0 +1,5 @@
+# ScopeProps
+
+```ts
+type ScopeProps = ScopePropsWithValue | ScopePropsWithInfo;
+```

package/docs/api/types/SoftlineIntrinsicElement.md

@@ -0,0 +1,5 @@
+# SoftlineIntrinsicElement
+
+```ts
+type SoftlineIntrinsicElement = IntrinsicElementBase<"softline">;
+```