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

package/docs/api/types/Children.md

@@ -0,0 +1,5 @@
+# Children
+
+```ts
+type Children = Child | Children[];
+```

package/docs/api/types/ChildrenOptions.md

@@ -0,0 +1,7 @@
+# ChildrenOptions
+
+## Members
+
+|                   |                  |                                                    |
+| ----------------- | ---------------- | -------------------------------------------------- |
+| preserveFragments | optional boolean | When true, fragments and arrays are not flattened. |

package/docs/api/types/CommonFormatOptions.md

@@ -0,0 +1,8 @@
+# CommonFormatOptions
+
+## Members
+
+Extends [PrintTreeOptions](../printtreeoptions/)
+
+|   |
+| - |

package/docs/api/types/Component.md

@@ -0,0 +1,8 @@
+# Component
+
+## Members
+
+|                |                             |   |
+| -------------- | --------------------------- | - |
+| Call signature | (props: TProps) => Children |   |
+| tag            | optional symbol             |   |

package/docs/api/types/ComponentContext.md

@@ -0,0 +1,11 @@
+# ComponentContext
+
+## Members
+
+|             |                                                                                                      |   |
+| ----------- | ---------------------------------------------------------------------------------------------------- | - |
+| default     | T \| undefined                                                                                       |   |
+| id          | symbol                                                                                               |   |
+| name        | optional string                                                                                      |   |
+| Provider    | [ComponentDefinition](../componentdefinition/)<[ContextProviderProps](../contextproviderprops/)\<T>> |   |
+| ProviderStc | [StcSignature](../stcsignature/)<[ContextProviderProps](../contextproviderprops/)\<T>>               |   |

package/docs/api/types/ComponentCreator.md

@@ -0,0 +1,11 @@
+# ComponentCreator
+
+## Members
+
+|                |                                                                            |   |
+| -------------- | -------------------------------------------------------------------------- | - |
+| Call signature | () => Children                                                             |   |
+| component      | [Component](../../../typescript/components/ensuretyperefcontext/)\<TProps> |   |
+| props          | TProps                                                                     |   |
+| source         | optional [SourceLocation](../sourcelocation/)                              |   |
+| tag            | optional symbol                                                            |   |

package/docs/api/types/ComponentDefinition.md

@@ -0,0 +1,7 @@
+# ComponentDefinition
+
+## Members
+
+|                |                             |   |
+| -------------- | --------------------------- | - |
+| Call signature | (props: TProps) => Children |   |

package/docs/api/types/ContentOutputFile.md

@@ -0,0 +1,10 @@
+# ContentOutputFile
+
+## Members
+
+Extends [OutputFileBase](../outputfilebase/)
+
+|          |        |   |
+| -------- | ------ | - |
+| contents | string |   |
+| filetype | string |   |

package/docs/api/types/ContentSlot.md

@@ -0,0 +1,12 @@
+# ContentSlot
+
+## Members
+
+|                |                                                                       |                                                                              |
+| -------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| Call signature | (props: { children: Children; }) => Children                          |                                                                              |
+| hasContent     | boolean                                                               | Whether the slot has any content.                                            |
+| isEmpty        | boolean                                                               | Whether the slot is currently empty.                                         |
+| ref            | Ref\<boolean>                                                         | A ref indicating whether the slot is currently empty.                        |
+| WhenEmpty      | [Component](../../../typescript/components/ensuretyperefcontext/)<{}> | A component that will render its contents when the content slot is empty.    |
+| WhenHasContent | [Component](../../../typescript/components/ensuretyperefcontext/)<{}> | A component that will render its contents when the content slot has content. |

package/docs/api/types/Context.md

@@ -0,0 +1,19 @@
+# Context
+
+## Members
+
+|                     |                                                                  |                                                                                                                                                                       |
+| ------------------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \_lastEmpty         | boolean                                                          | Cheap boolean tracking the last propagated empty state. Used by notifyContentState() for early-return optimization without requiring a reactive ref on every context. |
+| childrenWithContent | number                                                           | The number of child nodes that have content. When zero, this component is semantically empty.                                                                         |
+| componentOwner      | optional [ComponentCreator](../componentcreator/)\<unknown>      | When this context was created by a component, this will be the component that created it.                                                                             |
+| context             | optional Record\<symbol, unknown>                                |                                                                                                                                                                       |
+| disposables         | optional [Disposable\_2](../disposable_2/)\[]                    |                                                                                                                                                                       |
+| elementCache        | optional [ElementCache](../elementcache/)                        | A cache of RenderTextTree nodes created within this context, indexed by the component or function which created them.                                                 |
+| id                  | number                                                           | Monotonic numeric ID for trace/debug correlation.                                                                                                                     |
+| isEmpty             | optional Ref\<boolean>                                           | A ref that indicates whether the component is empty. Only allocated when reactively observed (ContentSlot, mapJoin).                                                  |
+| isRoot              | boolean                                                          | Whether this context is a root context                                                                                                                                |
+| meta                | optional Record\<string, any>                                    |                                                                                                                                                                       |
+| owner               | [Context](../context/) \| null                                   |                                                                                                                                                                       |
+| takenSymbols        | optional ShallowReactive\<Set<[OutputSymbol](../outputsymbol/)>> | The symbol that this component has taken.                                                                                                                             |
+| takesSymbols        | boolean                                                          | Whether this context will take an emitted symbol.                                                                                                                     |

package/docs/api/types/ContextProviderProps.md

@@ -0,0 +1,8 @@
+# ContextProviderProps
+
+## Members
+
+|          |                                   |   |
+| -------- | --------------------------------- | - |
+| children | optional [Children](../children/) |   |
+| value    | optional T                        |   |

package/docs/api/types/CopyFileContext.md

@@ -0,0 +1,8 @@
+# CopyFileContext
+
+## Members
+
+|            |        |   |
+| ---------- | ------ | - |
+| path       | string |   |
+| sourcePath | string |   |

package/docs/api/types/CopyOutputFile.md

@@ -0,0 +1,9 @@
+# CopyOutputFile
+
+## Members
+
+Extends [OutputFileBase](../outputfilebase/)
+
+|            |        |   |
+| ---------- | ------ | - |
+| sourcePath | string |   |

package/docs/api/types/CustomContext.md

@@ -0,0 +1,10 @@
+# CustomContext
+
+Create a custom reactive context for the children returned by the provided context.
+
+## Members
+
+|                         |                                                                                     |   |
+| ----------------------- | ----------------------------------------------------------------------------------- | - |
+| \[CUSTOM\_CONTEXT\_SYM] | true                                                                                |   |
+| useCustomContext        | (useCb: [CustomContextChildrenCallback](../customcontextchildrencallback/)) => void |   |

package/docs/api/types/CustomContextChildrenCallback.md

@@ -0,0 +1,5 @@
+# CustomContextChildrenCallback
+
+```ts
+type CustomContextChildrenCallback = (child: Children) => void;
+```

package/docs/api/types/DeclarationProps.md

@@ -0,0 +1,5 @@
+# DeclarationProps
+
+```ts
+type DeclarationProps = DeclarationPropsWithSymbol | DeclarationPropsWithInfo;
+```

package/docs/api/types/DedentIntrinsicElement.md

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

package/docs/api/types/DedentToRootIntrinsicElement.md

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

package/docs/api/types/Diagnostic.md

@@ -0,0 +1,11 @@
+# Diagnostic
+
+## Members
+
+|                |                                                              |   |
+| -------------- | ------------------------------------------------------------ | - |
+| componentStack | optional [DiagnosticStackEntry](../diagnosticstackentry/)\[] |   |
+| id             | string                                                       |   |
+| message        | string                                                       |   |
+| severity       | [DiagnosticSeverity](../diagnosticseverity/)                 |   |
+| source         | optional [SourceLocation](../sourcelocation/)                |   |

package/docs/api/types/DiagnosticHandle.md

@@ -0,0 +1,7 @@
+# DiagnosticHandle
+
+## Members
+
+|         |            |   |
+| ------- | ---------- | - |
+| dismiss | () => void |   |

package/docs/api/types/DiagnosticInput.md

@@ -0,0 +1,10 @@
+# DiagnosticInput
+
+## Members
+
+|                |                                                              |   |
+| -------------- | ------------------------------------------------------------ | - |
+| componentStack | optional [DiagnosticStackEntry](../diagnosticstackentry/)\[] |   |
+| message        | string                                                       |   |
+| severity       | optional [DiagnosticSeverity](../diagnosticseverity/)        |   |
+| source         | optional [SourceLocation](../sourcelocation/)                |   |

package/docs/api/types/DiagnosticSeverity.md

@@ -0,0 +1,5 @@
+# DiagnosticSeverity
+
+```ts
+type DiagnosticSeverity = "info" | "warning" | "error";
+```

package/docs/api/types/DiagnosticStackEntry.md

@@ -0,0 +1,9 @@
+# DiagnosticStackEntry
+
+## Members
+
+|              |                                               |   |
+| ------------ | --------------------------------------------- | - |
+| name         | string                                        |   |
+| renderNodeId | optional number                               |   |
+| source       | optional [SourceLocation](../sourcelocation/) |   |

package/docs/api/types/DiagnosticsCollector.md

@@ -0,0 +1,8 @@
+# DiagnosticsCollector
+
+## Members
+
+|                |                                              |   |
+| -------------- | -------------------------------------------- | - |
+| emit           | (input: DiagnosticInput) => DiagnosticHandle |   |
+| getDiagnostics | () => Diagnostic\[]                          |   |

package/docs/api/types/Disposable_2.md

@@ -0,0 +1,7 @@
+# Disposable_2
+
+## Members
+
+|                |            |   |
+| -------------- | ---------- | - |
+| Call signature | () => void |   |

package/docs/api/types/EffectDebugOptions.md

@@ -0,0 +1,8 @@
+# EffectDebugOptions
+
+## Members
+
+|      |                 |   |
+| ---- | --------------- | - |
+| name | optional string |   |
+| type | optional string |   |

package/docs/api/types/EffectOptions.md

@@ -0,0 +1,7 @@
+# EffectOptions
+
+## Members
+
+|       |                                                       |   |
+| ----- | ----------------------------------------------------- | - |
+| debug | optional [EffectDebugOptions](../effectdebugoptions/) |   |

package/docs/api/types/ElementCache.md

@@ -0,0 +1,5 @@
+# ElementCache
+
+```ts
+type ElementCache = Map<ElementCacheKey, RenderedTextTree>;
+```

package/docs/api/types/ElementCacheKey.md

@@ -0,0 +1,5 @@
+# ElementCacheKey
+
+```ts
+type ElementCacheKey = ComponentCreator | (() => unknown) | CustomContext;
+```

package/docs/api/types/FillIntrinsicElement.md

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

package/docs/api/types/ForCallbackArgs.md

@@ -0,0 +1,5 @@
+# ForCallbackArgs
+
+```ts
+type ForCallbackArgs<T> = number extends keyof T ? [value: T[number]] : T extends Ref<infer U> ? ForCallbackArgs<U> : T extends () => infer U ? ForCallbackArgs<U> : T extends Map<infer U, infer V> ? [key: U, value: V] : T extends Set<infer U> ? [value: U] : T extends IterableIterator<infer U> ? [value: U] : [];
+```

package/docs/api/types/ForSupportedCollections.md

@@ -0,0 +1,5 @@
+# ForSupportedCollections
+
+```ts
+type ForSupportedCollections = readonly unknown[] | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | IterableIterator<unknown>;
+```

package/docs/api/types/GroupIntrinsicElement.md

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

package/docs/api/types/HardlineIntrinsicElement.md

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

package/docs/api/types/HbrIntrinsicElement.md

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

package/docs/api/types/IfBreakIntrinsicElement.md

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

package/docs/api/types/IndentIfBreakIntrinsicElement.md

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

package/docs/api/types/IndentIntrinsicElement.md

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

package/docs/api/types/IntrinsicElement.md

@@ -0,0 +1,5 @@
+# IntrinsicElement
+
+```ts
+type IntrinsicElement = IndentIntrinsicElement | IndentIfBreakIntrinsicElement | BrIntrinsicElement | LineIntrinsicElement | HbrIntrinsicElement | HardlineIntrinsicElement | SbrIntrinsicElement | SoftlineIntrinsicElement | GroupIntrinsicElement | AlignIntrinsicElement | FillIntrinsicElement | BreakParentIntrinsicElement | LineSuffixIntrinsicElement | LineSuffixBoundaryIntrinsicElement | DedentIntrinsicElement | LiterallineIntrinsicElement | LbrIntrinsicElement | DedentToRootIntrinsicElement | MarkAsRootIntrinsicElement | IfBreakIntrinsicElement;
+```

package/docs/api/types/IntrinsicElementBase.md

@@ -0,0 +1,9 @@
+# IntrinsicElementBase
+
+## Members
+
+|                        |                                                   |   |
+| ---------------------- | ------------------------------------------------- | - |
+| \[intrinsicElementKey] | true                                              |   |
+| name                   | TKey                                              |   |
+| props                  | [IntrinsicElements](../intrinsicelements/)\[TKey] |   |

package/docs/api/types/IntrinsicElements.md

@@ -0,0 +1,26 @@
+# IntrinsicElements
+
+## Members
+
+|                    |                                                                                                                   |                                                                                                                                                                                                                                                 |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| align              | { children: [Children](../children/); width: number; } \| { children: [Children](../children/); string: string; } | Indent the children of this component by either the number of characters indicated by the `width` prop, or by the provided string indicated by the `string` prop.                                                                               |
+| br                 | {}                                                                                                                | A regular line break. This will break if the line exceeds the print width, otherwise it will be a space.                                                                                                                                        |
+| breakParent        | {}                                                                                                                | Force the parent group to break.                                                                                                                                                                                                                |
+| dedent             | { children: [Children](../children/); }                                                                           | Decrease the indentation level of the children of this component. Indentation is determined by the print options provided to the Output component or source file.                                                                               |
+| dedentToRoot       | { children: [Children](../children/); }                                                                           | Decrease the indentation level to the root level specified by `<markAsRoot />`, or else to no indentation.                                                                                                                                      |
+| fill               | { children: [Children](../children/); }                                                                           | Similar to `group`, but will only place a line break before the last segment to exceed the print width. This is useful for formatting paragraphs of text where breaks are inserted prior to words which would otherwise exceed the print width. |
+| group              | { shouldBreak?: boolean; id?: symbol; children: [Children](../children/); }                                       | Attempt to render the children on a single line if possible. If a group contains `<breakParent />` or a hard line, or if the group exceeds the print width, all linebreaks in the group will be broken.                                         |
+| hardline           | {}                                                                                                                | A hard line break. This is a line that will always break, even if the group does not exceed print width.                                                                                                                                        |
+| hbr                | {}                                                                                                                | A hard line break. This is a line that will always break, even if the group does not exceed print width.                                                                                                                                        |
+| ifBreak            | { children: [Children](../children/); flatContents?: [Children](../children/); groupId?: symbol; }                | Print children if the current group or already printed group specified by `groupId` is broken. Otherwise, `flatContents` is printed instead.                                                                                                    |
+| indent             | { children: [Children](../children/); }                                                                           | Increase the indentation level of the children of this component. Indentation is determined by the print options provided to the Output component or source file.                                                                               |
+| indentIfBreak      | { children: [Children](../children/); groupId: symbol; negate?: boolean; }                                        | Indent the children of this component if the group specified by `groupId` is broken (or not broken if `negate` is passed). The specified group must already be printed.                                                                         |
+| lbr                | {}                                                                                                                | A literal line break. This will always break, even if the group does not exceed print width. The new line will ignore indentation.                                                                                                              |
+| line               | {}                                                                                                                | A regular line break. This will break if the line exceeds the print width, otherwise it will be a space.                                                                                                                                        |
+| lineSuffix         | { children: [Children](../children/); }                                                                           | Print this content at the end of the line. Useful for things like line comments.                                                                                                                                                                |
+| lineSuffixBoundary | {}                                                                                                                | Force any line suffixes to print at this point.                                                                                                                                                                                                 |
+| literalline        | {}                                                                                                                | A literal line break. This will always break, even if the group does not exceed print width. The new line will ignore indentation.                                                                                                              |
+| markAsRoot         | { children: [Children](../children/); }                                                                           | Mark the current indentation level as “root” for the purposes of literal line breaks and `dedentToRoot`.                                                                                                                                        |
+| sbr                | {}                                                                                                                | A soft line break. This will break if the line exceeds the print width, otherwise it will be be nothing.                                                                                                                                        |
+| softline           | {}                                                                                                                | A soft line break. This will break if the line exceeds the print width, otherwise it will be be nothing.                                                                                                                                        |

package/docs/api/types/JoinOptions.md

@@ -0,0 +1,9 @@
+# JoinOptions
+
+## Members
+
+|           |                                   |                                                                                                                                                                                           |
+| --------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ender     | optional [Children](../children/) | When true, the joiner is placed at the end of the array. When a string, that string is placed at the end of the array. The ender is only emitted when the array has at least one element. |
+| joiner    | optional [Children](../children/) | The string to place between each element.                                                                                                                                                 |
+| skipFalsy | optional boolean                  | When true, falsy values with the exception of 0 are skipped.                                                                                                                              |

package/docs/api/types/LbrIntrinsicElement.md

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

package/docs/api/types/LibrarySymbolReference.md

@@ -0,0 +1,13 @@
+# LibrarySymbolReference
+
+An object that acts as a lazy reference to an external library symbol. Implements [REFKEYABLE](../../variables/refkeyable/) and `[TO_SYMBOL]()`.
+
+Use [isLibrarySymbolReference](../../functions/islibrarysymbolreference/) to test whether an unknown value is a library symbol reference.
+
+## Members
+
+Extends [RefkeyableObject](../refkeyableobject/)
+
+|               |                    |   |
+| ------------- | ------------------ | - |
+| \[TO\_SYMBOL] | () => OutputSymbol |   |

package/docs/api/types/LineIntrinsicElement.md

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

package/docs/api/types/LineSuffixBoundaryIntrinsicElement.md

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

package/docs/api/types/LineSuffixIntrinsicElement.md

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

package/docs/api/types/LiterallineIntrinsicElement.md

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

package/docs/api/types/MakeChildrenOptional.md

@@ -0,0 +1,7 @@
+# MakeChildrenOptional
+
+```ts
+type MakeChildrenOptional<T extends object> = T extends {
+    children?: any;
+} ? Omit<T, "children"> & Partial<Pick<T, "children">> : T;
+```

package/docs/api/types/MarkAsRootIntrinsicElement.md

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

package/docs/api/types/MatchProps.md

@@ -0,0 +1,9 @@
+# MatchProps
+
+## Members
+
+|          |                          |                                                                                                               |
+| -------- | ------------------------ | ------------------------------------------------------------------------------------------------------------- |
+| children | [Children](../children/) |                                                                                                               |
+| else     | optional boolean         | If no `when` is matched, the children of this element will be rendered. The `else` match must be placed last. |
+| when     | optional boolean         | Condition under which the children of this element will be rendered.                                          |

package/docs/api/types/MemberDeclarationProps.md

@@ -0,0 +1,5 @@
+# MemberDeclarationProps
+
+```ts
+type MemberDeclarationProps = MemberDeclarationPropsWithInfo | MemberDeclarationPropsWithSymbol;
+```

package/docs/api/types/MemberDescriptor.md

@@ -0,0 +1,10 @@
+# MemberDescriptor
+
+Describes a member in a member access chain, tracking both the symbol and whether this specific member was accessed via a memberRefkey.
+
+## Members
+
+|                |                                  |   |
+| -------------- | -------------------------------- | - |
+| isMemberAccess | boolean                          |   |
+| symbol         | [OutputSymbol](../outputsymbol/) |   |

package/docs/api/types/MemberRefkey.md

@@ -0,0 +1,10 @@
+# MemberRefkey
+
+## Members
+
+Extends [RefkeyableObject](../refkeyableobject/)
+
+|        |                                |   |
+| ------ | ------------------------------ | - |
+| base   | [Refkey](../refkey/)           |   |
+| member | [Refkey](../refkey/) \| string |   |

package/docs/api/types/MemberResolutionContext.md

@@ -0,0 +1,10 @@
+# MemberResolutionContext
+
+The context for a member resolution. This is used to properly resolve a member in the MemberResolver.
+
+## Members
+
+|                |           |                                                                                                                                                                                                        |
+| -------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| isMemberAccess | boolean   | Whether we are using member access e.g. via `memberRefkey`. This is true when the member was resolved using a memberRefkey, which may carry additional metadata about the member access in the future. |
+| referencePath  | TScope\[] | The scopes that the member reference occurred in.                                                                                                                                                      |

package/docs/api/types/MemberResolver.md

@@ -0,0 +1,32 @@
+# MemberResolver
+
+A callback that performs access-control filtering during member resolution.
+
+## Members
+
+|                |                                                                                      |   |
+| -------------- | ------------------------------------------------------------------------------------ | - |
+| Call signature | (owner: TSymbol, member: TSymbol, context: MemberResolutionContext\<TScope>) => void |   |
+
+## Remarks
+
+When provided to [ResolveDeclarationByKeyOptions](../resolvedeclarationbykeyoptions/), it entirely replaces the default checks (ownership assertion and `isMemberSymbol` assertion).
+
+**Contract:**
+
+* **Return `void`** to accept the member.
+* **Throw an error** to reject the member — the error propagates to the caller, matching the behavior of the default checks.
+
+## Example
+
+```ts
+const resolver: MemberResolver<MyScope, MySymbol> = (owner, member, ctx) => {
+  if (member.isPrivate && !ctx.isMemberAccess) {
+    throw new Error(`${member.name} is not accessible here`);
+  }
+};
+```
+
+## See also
+
+* [MemberResolutionContext](../memberresolutioncontext/) for available context properties.

package/docs/api/types/MemberScopeProps.md

@@ -0,0 +1,5 @@
+# MemberScopeProps
+
+```ts
+type MemberScopeProps = MemberScopePropsWithValue | MemberScopePropsWithInfo;
+```

package/docs/api/types/Metadata.md

@@ -0,0 +1,5 @@
+# Metadata
+
+```ts
+type Metadata = object;
+```

package/docs/api/types/NameConflictResolver.md

@@ -0,0 +1,27 @@
+# NameConflictResolver
+
+A callable interface invoked by the binder when two or more symbols in the same scope share a name. The resolver mutates symbol names to eliminate conflicts (e.g., appending `_2`, `_3`).
+
+## Members
+
+|                |                                                  |   |
+| -------------- | ------------------------------------------------ | - |
+| Call signature | (name: string, symbols: OutputSymbol\[]) => void |   |
+
+## Remarks
+
+The resolver is called with the shared `name` and all symbols in the scope that have that original name. Rename a symbol by assigning to `symbol.name`. Symbols with `ignoreNameConflict: true` are excluded. The default resolver keeps the first symbol unchanged and renames subsequent ones `originalName + "_2"`, `originalName + "_3"`, etc.
+
+Assigned names pass through the active name policy before being stored; design suffixes to produce the correct final name after policy transformation, or set `ignoreNamePolicy` on the symbol after resolution.
+
+Conflict detection is keyed on `originalName` (see \[unresolved link]). Symbols that differ in original name but normalize to the same policy-applied name are never detected as conflicting.
+
+## Example
+
+```ts
+const resolver: NameConflictResolver = (name, symbols) => {
+  for (let i = 1; i < symbols.length; i++) {
+    symbols[i].name = symbols[i].originalName + "_" + (i + 1);
+  }
+};
+```