@alloy-js/core 0.15.0 → 0.17.0

package/dist/src/symbols/output-symbol.js

@@ -0,0 +1,379 @@
+import { reactive, ReactiveFlags, shallowReactive, track, TrackOpTypes, trigger, TriggerOpTypes, watch } from "@vue/reactivity";
+import { useBinder } from "../context/binder.js";
+import { useMemberScope } from "../context/member-scope.js";
+import { useScope } from "../context/scope.js";
+import { isRefkey, refkey } from "../refkey.js";
+import { formatScopeName, formatSymbol, formatSymbolName, trace, traceEffect, TracePhase } from "../tracer.js";
+import { OutputScope, OutputScopeFlags } from "./output-scope.js";
+/**
+ * Flags that describe an output symbol.
+ */
+export let OutputSymbolFlags = /*#__PURE__*/function (OutputSymbolFlags) {
+  OutputSymbolFlags[OutputSymbolFlags["None"] = 0] = "None";
+  /**
+   * The symbol is an instance member container. Symbols with this flag will have a
+   * instanceMemberScope property that contains symbols for instance members.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["InstanceMemberContainer"] = 1] = "InstanceMemberContainer";
+  /**
+   * The symbol is a static member container. Symbols with this flag will have a
+   * staticMemberScope property that contains symbols for static members.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["StaticMemberContainer"] = 2] = "StaticMemberContainer";
+  /**
+   * Whether this symbol contains members of any kind.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["MemberContainer"] = 3] = "MemberContainer";
+  /**
+   * Whether this symbol is an instance member of another symbol (i.e that it is
+   * stored in an instance member scope).
+   */
+  OutputSymbolFlags[OutputSymbolFlags["InstanceMember"] = 4] = "InstanceMember";
+  /**
+   * Whether this symbol is a static member of another symbol (i.e that it is
+   * stored in a static member scope).
+   */
+  OutputSymbolFlags[OutputSymbolFlags["StaticMember"] = 8] = "StaticMember";
+  /**
+   * Transient symbols are not added to symbol tables and do not create
+   * referencable refkeys. They are used for temporary symbols that are intended
+   * to be used to calculate other symbols.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["Transient"] = 16] = "Transient";
+  /**
+   * This symbol aliases another symbol. Only its name, flags, and scope are
+   * stored in this symbol. Otherwise, everything else is located on the alias
+   * target.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["Alias"] = 32] = "Alias";
+  /**
+   * Whether this is an instance member or static member of another symbol.
+   */
+  OutputSymbolFlags[OutputSymbolFlags["Member"] = 12] = "Member";
+  return OutputSymbolFlags;
+}({});
+let symbolCount = 0;
+
+/**
+ * An output symbol is a named entity that can be referenced in your output
+ * code.
+ *
+ * @remarks
+ *
+ * This class is the base implementation of symbol. Most languages will have
+ * subtypes that provide additional metadata. Symbols are reactive values, so
+ * you can observe changes to their properties in a reactive context.
+ */
+export class OutputSymbol {
+  #originalName;
+  get originalName() {
+    return this.#originalName;
+  }
+  #name;
+  get name() {
+    track(this, TrackOpTypes.GET, "name");
+    return this.#name;
+  }
+  set name(name) {
+    const old = this.#name;
+    if (old === name) {
+      return;
+    }
+    this.#name = name;
+    trigger(this, TriggerOpTypes.SET, "name", name, old);
+  }
+  #id;
+  get id() {
+    return this.#id;
+  }
+  #flags;
+  get flags() {
+    track(this, TrackOpTypes.GET, "flags");
+    return this.#flags;
+  }
+  set flags(flags) {
+    const old = this.#flags;
+    if (old === flags) {
+      return;
+    }
+    this.#flags = flags;
+    trigger(this, TriggerOpTypes.SET, "flags", flags, old);
+    this.#createInstanceMemberScope();
+    this.#createStaticMemberScope();
+  }
+  #scope;
+  get scope() {
+    track(this, TrackOpTypes.GET, "scope");
+    return this.#scope;
+  }
+  set scope(scope) {
+    const old = this.#scope;
+    if (old === scope) {
+      return;
+    }
+    this.#handleNewScope(scope, old);
+    this.#scope = scope;
+    trigger(this, TriggerOpTypes.SET, "scope", scope, old);
+  }
+  #handleNewScope(newScope, oldScope) {
+    if (oldScope) {
+      // ensure when changing scope that this symbol only belongs to one of them
+      oldScope.symbols.delete(this);
+    }
+    if (!newScope) {
+      return;
+    }
+    newScope.symbols.add(this);
+    if (newScope.flags & OutputScopeFlags.InstanceMemberScope) {
+      this.flags |= OutputSymbolFlags.InstanceMember;
+    }
+    if (newScope.flags & OutputScopeFlags.StaticMemberScope) {
+      this.flags |= OutputSymbolFlags.StaticMember;
+    }
+  }
+  #binder;
+  get binder() {
+    return this.#binder;
+  }
+  #refkeys;
+  get refkeys() {
+    track(this, TrackOpTypes.GET, "refkeys");
+    return this.#refkeys;
+  }
+  set refkeys(refkeys) {
+    const old = this.#refkeys;
+    if (old === refkeys) {
+      return;
+    }
+    this.#refkeys = shallowReactive(Array.isArray(refkeys) ? refkeys : [refkeys]);
+    trigger(this, TriggerOpTypes.SET, "refkeys", this.#refkeys, old);
+  }
+  #instanceMemberScope;
+  get instanceMemberScope() {
+    track(this, TrackOpTypes.GET, "instanceMemberScope");
+    return this.#instanceMemberScope;
+  }
+  #aliasTarget;
+  get aliasTarget() {
+    return this.#aliasTarget;
+  }
+  #createInstanceMemberScope() {
+    if (this.#instanceMemberScope || !(this.#flags & OutputSymbolFlags.InstanceMemberContainer)) {
+      return;
+    }
+    this.#instanceMemberScope = new OutputScope(`${this.name} instance members`, {
+      binder: this.#binder,
+      owner: this,
+      flags: OutputScopeFlags.InstanceMemberScope
+    });
+    trigger(this, TriggerOpTypes.SET, "instanceMemberScope", this.#instanceMemberScope, undefined);
+  }
+
+  /**
+   * Create an output scope to hold member symbols. By default this just creates
+   * an OutputScope, but can be subclassed to build scope subtypes when needed.
+   */
+  createMemberScope(name, options) {
+    return new OutputScope(name, {
+      binder: this.#binder,
+      owner: options.owner,
+      flags: options.flags
+    });
+  }
+  #staticMemberScope;
+  get staticMemberScope() {
+    track(this, TrackOpTypes.GET, "staticMemberScope");
+    return this.#staticMemberScope;
+  }
+  #createStaticMemberScope() {
+    if (this.#staticMemberScope || !(this.#flags & OutputSymbolFlags.StaticMemberContainer)) {
+      return;
+    }
+    this.#staticMemberScope = new OutputScope(`${this.name} static members`, {
+      binder: this.#binder,
+      owner: this,
+      flags: OutputScopeFlags.StaticMemberScope
+    });
+    trigger(this, TriggerOpTypes.SET, "staticMemberScope", this.#staticMemberScope, undefined);
+  }
+  #metadata;
+  get metadata() {
+    return this.#metadata;
+  }
+
+  /**
+   * Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
+   * proxy.
+   */
+  [ReactiveFlags.SKIP] = true;
+  constructor(name, options = {}) {
+    this.#binder = options.binder ?? useBinder();
+    this.#name = name;
+    this.#originalName = name;
+    this.#id = symbolCount++;
+    this.#flags = options.flags ?? OutputSymbolFlags.None;
+    this.#scope = options.scope ?? this.#defaultScope();
+    this.#aliasTarget = options.aliasTarget;
+    if (this.#aliasTarget) {
+      this.#flags |= OutputSymbolFlags.Alias;
+      this.#flags &= ~(OutputSymbolFlags.MemberContainer | OutputSymbolFlags.Member);
+    }
+    this.#refkeys = shallowReactive(Array.isArray(options.refkeys) ? options.refkeys : isRefkey(options.refkeys) ? [options.refkeys] : []);
+    this.#metadata = reactive(options.metadata ?? {});
+    this.#createInstanceMemberScope();
+    this.#createStaticMemberScope();
+    this.#handleNewScope(this.#scope);
+    trace(TracePhase.symbol.create, () => `${formatSymbol(this)}`);
+    traceEffect(TracePhase.symbol.update, () => {
+      return `${formatSymbol(this)}`;
+    });
+    this.#binder?.notifySymbolCreated(this);
+  }
+  delete() {
+    trace(TracePhase.symbol.delete, () => `${formatSymbolName(this)}`);
+    if (this.#scope) {
+      this.#scope.symbols.delete(this);
+    }
+    this.#binder?.notifySymbolDeleted(this);
+  }
+
+  /**
+   * Takes the instance members or static members on this symbol and creates
+   * corresponding static members on the target symbol. Instance or static
+   * members of instantiated symbols are copied. The refkey of any instantiated
+   * symbols are set to a composite refkey of the target symbol's refkey and the
+   * instantiated symbol's refkey.
+   */
+  instantiateTo(targetSymbol) {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.instantiateTo(targetSymbol);
+    }
+    trace(TracePhase.symbol.instantiate, () => {
+      return `${formatSymbolName(this)} -> ${formatSymbolName(targetSymbol)}`;
+    });
+    const from = this.#instanceMemberScope ?? this.#staticMemberScope;
+    if (from) {
+      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
+      targetSymbol.#createStaticMemberScope();
+      targetSymbol.#staticMemberScope.copySymbolsFrom(from, {
+        onAdd: symbol => {
+          const clone = symbol.copyToScope(targetSymbol.#staticMemberScope, targetSymbol);
+          clone.#flags &= ~OutputSymbolFlags.InstanceMember;
+          clone.#flags |= OutputSymbolFlags.StaticMember;
+          return clone;
+        }
+      });
+    }
+  }
+  #instantiationRk(base, member) {
+    const instantiationRks = [];
+    for (const baseRk of base.refkeys) {
+      for (const targetRk of member.refkeys) {
+        instantiationRks.push(refkey(baseRk, targetRk));
+      }
+    }
+    return instantiationRks;
+  }
+
+  /**
+   * Copy member symbols from the target symbol into the target symbol. The
+   * copied symbols have their refkey set to
+   * `refkey(targetSymbol.refkey, this.refkey)`.
+   */
+  copyTo(targetSymbol) {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.copyTo(targetSymbol);
+    }
+    if (this.staticMemberScope) {
+      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
+      targetSymbol.staticMemberScope.copySymbolsFrom(this.staticMemberScope);
+    }
+    if (this.instanceMemberScope) {
+      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
+      targetSymbol.instanceMemberScope.copySymbolsFrom(this.instanceMemberScope);
+    }
+  }
+
+  /**
+   * Move member symbols from this transient symbol to the target symbol.
+   */
+  moveTo(targetSymbol) {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.moveTo(targetSymbol);
+    }
+    if (!(this.flags & OutputSymbolFlags.Transient)) {
+      throw new Error("Can only move members from transient symbols");
+    }
+    if (this.staticMemberScope) {
+      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
+      targetSymbol.staticMemberScope.moveSymbolsFrom(this.staticMemberScope);
+    }
+    if (this.instanceMemberScope) {
+      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
+      targetSymbol.instanceMemberScope.moveSymbolsFrom(this.instanceMemberScope);
+    }
+  }
+
+  /**
+   * Makes a copy of this symbol which will update the name and flags
+   * of the clone when the original symbol is updated.
+   *
+   * @remarks
+   *
+   * This is used to create a symbol that is a copy of this symbol, but
+   * with a different scope. Changes to the copy will not affect the
+   * original symbol, and changes to the original symbol's name and flags
+   * will overwrite the copy's name and flags.
+   *
+   * @param newScope - The scope to use for the copy.
+   */
+  copyToScope(newScope, baseSymbol) {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.copyToScope(newScope, baseSymbol);
+    }
+    trace(TracePhase.symbol.clone, () => {
+      return `${formatSymbolName(this)} -> ${formatScopeName(newScope)}`;
+    });
+    const clone = new OutputSymbol(this.#name, {
+      binder: this.#binder,
+      scope: newScope,
+      flags: this.#flags,
+      refkeys: baseSymbol ? this.#instantiationRk(baseSymbol, this) : [],
+      metadata: this.#metadata
+    });
+    if (this.instanceMemberScope) {
+      clone.#instanceMemberScope = this.instanceMemberScope.clone({
+        owner: clone
+      });
+    }
+    if (this.staticMemberScope) {
+      clone.#staticMemberScope = this.staticMemberScope.clone({
+        owner: clone
+      });
+    }
+    watch(() => this.name, newName => clone.name = newName);
+    watch(() => this.flags, newFlags => clone.flags = newFlags);
+    return clone;
+  }
+  #defaultScope() {
+    if ((this.#flags & OutputSymbolFlags.Member) === 0) {
+      return useScope();
+    } else {
+      const memberScope = useMemberScope();
+      if (!memberScope) {
+        throw new Error("Cannot declare member symbols without a member scope");
+      }
+      if (this.#flags & OutputSymbolFlags.InstanceMember) {
+        if (!memberScope.instanceMembers) {
+          throw new Error("Cannot declare instance member symbols without an instance member scope");
+        }
+        return memberScope.instanceMembers;
+      } else {
+        if (!memberScope.staticMembers) {
+          throw new Error("Cannot declare static member symbols without a static member scope");
+        }
+        return memberScope.staticMembers;
+      }
+    }
+  }
+}

package/dist/src/symbols/symbol-flow.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from "@vue/reactivity";
+import { OutputSymbol } from "./output-symbol.js";
+export interface TakeSymbolCallback {
+    (symbol: OutputSymbol): void;
+}
+export interface TakeSymbolsCallback {
+    (symbols: Set<OutputSymbol>): void;
+}
+export declare function takeSymbols(cb?: (symbol: OutputSymbol) => void): import("@vue/reactivity").ShallowReactive<Set<OutputSymbol>>;
+export declare function emitSymbol(symbol: OutputSymbol | Ref<OutputSymbol | undefined>): void;
+export declare function moveTakenMembersTo(baseSymbol: OutputSymbol): void;
+export declare function instantiateTakenMembersTo(baseSymbol: OutputSymbol): void;
+//# sourceMappingURL=symbol-flow.d.ts.map

package/dist/src/symbols/symbol-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-flow.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-flow.ts"],"names":[],"mappings":"AAMA,OAAO,EAAS,GAAG,EAAmB,MAAM,iBAAiB,CAAC;AAI9D,OAAO,EAAE,YAAY,EAAqB,MAAM,oBAAoB,CAAC;AAErE,MAAM,WAAW,kBAAkB;IACjC,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,OAAO,EAAE,GAAG,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,gEAiB9D;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC,QA+CrD;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,YAAY,QAU1D;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,YAAY,QAEjE"}

package/dist/src/symbols/symbol-flow.js

@@ -0,0 +1,74 @@
+import { effect, getContext, onCleanup } from "@alloy-js/core/jsx-runtime";
+import { isRef, shallowReactive } from "@vue/reactivity";
+import { MemberScopeContext } from "../context/member-scope.js";
+import { ScopeContext } from "../context/scope.js";
+import { OutputSymbolFlags } from "./output-symbol.js";
+export function takeSymbols(cb) {
+  const context = getContext();
+  context.takesSymbols = true;
+  context.takenSymbols = shallowReactive(new Set());
+  if (cb) {
+    effect(oldSymbols => {
+      for (const symbol of context.takenSymbols) {
+        if (oldSymbols && oldSymbols.has(symbol)) {
+          continue;
+        }
+        cb(symbol);
+      }
+      return new Set(context.takenSymbols);
+    });
+  }
+  return context.takenSymbols;
+}
+export function emitSymbol(symbol) {
+  let symbolTaker;
+  let context = getContext().owner;
+  while (context) {
+    if (context.takesSymbols) {
+      symbolTaker = context;
+      break;
+    }
+    if (context.context && (context.context[ScopeContext.id] || context.context[MemberScopeContext.id])) {
+      // don't cross scope boundaries.
+      break;
+    }
+    context = context.owner;
+  }
+  if (!symbolTaker) {
+    return;
+  }
+  if (isRef(symbol)) {
+    effect(prevSymbol => {
+      onCleanup(() => {
+        if (symbol.value) {
+          symbolTaker.takenSymbols.delete(symbol.value);
+        }
+      });
+      if (symbol.value === undefined) {
+        symbolTaker.takenSymbols.delete(prevSymbol);
+        return undefined;
+      } else {
+        symbolTaker.takenSymbols.add(symbol.value);
+        return symbol.value;
+      }
+    });
+  } else {
+    symbolTaker.takenSymbols.add(symbol);
+    onCleanup(() => {
+      context.takenSymbols.delete(symbol);
+    });
+  }
+}
+export function moveTakenMembersTo(baseSymbol) {
+  const taken = takeSymbols();
+  effect(() => {
+    for (const symbol of taken) {
+      if (symbol.flags & OutputSymbolFlags.Transient) {
+        symbol.moveTo(baseSymbol);
+      }
+    }
+  });
+}
+export function instantiateTakenMembersTo(baseSymbol) {
+  takeSymbols(symbol => symbol.instantiateTo(baseSymbol));
+}

package/dist/src/symbols/symbol-slot.d.ts

@@ -0,0 +1,12 @@
+import { Ref, ShallowReactive } from "@vue/reactivity";
+import { Children } from "../jsx-runtime.js";
+import { OutputSymbol } from "./output-symbol.js";
+export declare function createSymbolSlot(): {
+    (props: {
+        children: Children;
+    }): Children;
+    ref: Ref<ShallowReactive<Set<OutputSymbol>> | undefined, ShallowReactive<Set<OutputSymbol>> | undefined>;
+    instantiateInto(baseSymbol: OutputSymbol): void;
+    copyInto(baseSymbol: OutputSymbol): void;
+};
+//# sourceMappingURL=symbol-slot.d.ts.map

package/dist/src/symbols/symbol-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-slot.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-slot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,eAAe,EAAc,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAqB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,wBAAgB,gBAAgB;YAGH;QAAE,QAAQ,EAAE,QAAQ,CAAA;KAAE;;gCAaP,YAAY;yBAYnB,YAAY;EAahD"}

package/dist/src/symbols/symbol-slot.js

@@ -0,0 +1,36 @@
+import { shallowRef } from "@vue/reactivity";
+import { effect, onCleanup } from "../jsx-runtime.js";
+import { takeSymbols } from "./symbol-flow.js";
+export function createSymbolSlot() {
+  const symbolSlotRef = shallowRef();
+  function SymbolSlot(props) {
+    const set = takeSymbols();
+    symbolSlotRef.value = set;
+    onCleanup(() => {
+      symbolSlotRef.value = undefined;
+    });
+    return props.children;
+  }
+  SymbolSlot.ref = symbolSlotRef;
+  SymbolSlot.instantiateInto = baseSymbol => {
+    effect(() => {
+      if (!symbolSlotRef.value) {
+        return;
+      }
+      for (const symbol of symbolSlotRef.value) {
+        symbol.instantiateTo(baseSymbol);
+      }
+    });
+  };
+  SymbolSlot.copyInto = baseSymbol => {
+    effect(() => {
+      if (!symbolSlotRef.value) {
+        return;
+      }
+      for (const symbol of symbolSlotRef.value) {
+        symbol.copyTo(baseSymbol);
+      }
+    });
+  };
+  return SymbolSlot;
+}

package/dist/src/symbols/symbol-table.d.ts

@@ -0,0 +1,14 @@
+import { NameConflictResolver } from "../binder.js";
+import { ReactiveUnionSet } from "../reactive-union-set.js";
+import { OutputScope } from "./output-scope.js";
+import { OutputSymbol } from "./output-symbol.js";
+export declare class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
+    private _namesToDeconflict;
+    private _nameConflictResolver?;
+    private _deconflictNames;
+    scope: OutputScope;
+    constructor(scope: OutputScope, options?: {
+        nameConflictResolver?: NameConflictResolver;
+    });
+}
+//# sourceMappingURL=symbol-table.d.ts.map

package/dist/src/symbols/symbol-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-table.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAQ5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,qBAAa,WAAY,SAAQ,gBAAgB,CAAC,YAAY,CAAC;IAC7D,OAAO,CAAC,kBAAkB,CAA0B;IACpD,OAAO,CAAC,qBAAqB,CAAC,CAAuB;IACrD,OAAO,CAAC,gBAAgB,CAYtB;IACK,KAAK,cAAC;gBAEX,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE;QACP,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;KACxC;CA2BT"}

package/dist/src/symbols/symbol-table.js

@@ -0,0 +1,42 @@
+import { ReactiveUnionSet } from "../reactive-union-set.js";
+import { queueJob } from "../scheduler.js";
+import { formatScopeName, formatSymbolName, trace, TracePhase } from "../tracer.js";
+export class SymbolTable extends ReactiveUnionSet {
+  _namesToDeconflict = new Set();
+  _deconflictNames = () => {
+    for (const name of this._namesToDeconflict) {
+      const conflictedSymbols = [...this].filter(sym => sym.originalName === name);
+      if (this._nameConflictResolver) {
+        this._nameConflictResolver(name, conflictedSymbols);
+      } else {
+        defaultConflictHandler(name, conflictedSymbols);
+      }
+      this._namesToDeconflict.delete(name);
+    }
+  };
+  constructor(scope, options = {}) {
+    super({
+      onAdd: symbol => {
+        trace(TracePhase.symbol.addToScope, () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`);
+        this._namesToDeconflict.add(symbol.name);
+        queueJob(this._deconflictNames);
+        return symbol;
+      },
+      onDelete(symbol) {
+        trace(TracePhase.symbol.removeFromScope, () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`);
+      }
+    });
+    this.scope = scope;
+    this._nameConflictResolver = options.nameConflictResolver;
+  }
+}
+
+/**
+ * Default conflict handler. This will rename all but the first symbol
+ * to have a suffix of _2, _3, etc.
+ */
+function defaultConflictHandler(_, conflictedSymbols) {
+  for (let i = 1; i < conflictedSymbols.length; i++) {
+    conflictedSymbols[i].name = conflictedSymbols[i].originalName + "_" + (i + 1);
+  }
+}

package/dist/src/tap.d.ts

@@ -1,7 +1,8 @@
 import { ShallowRef } from "@vue/reactivity";
-import { OutputScope, OutputSymbol } from "./binder.js";
 import { SourceFileContext } from "./context/source-file.js";
 import { ComponentDefinition } from "./jsx-runtime.js";
+import { OutputScope } from "./symbols/output-scope.js";
+import { OutputSymbol } from "./symbols/output-symbol.js";
 /**
  * The return value of {@link createTap}, this holds a reference to the tapped
  * value. It will be undefined until the tapped value is initialized.

package/dist/src/tap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../src/tap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,CAAE,SAAQ,mBAAmB;IACjD,+BAA+B;IAC/B,GAAG,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,IAAI,CAAC,GAAG,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EACnC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GACtB,GAAG,CAAC,CAAC,CAAC,CAcR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,SAAS,YAAY,GAAG,YAAY,EAC3C,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,gBAI9B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,YAAY,GAAG,YAAY,EACzE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,gBAK9B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,SAAS,WAAW,GAAG,WAAW,EACrE,OAAO,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,eAK7B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,0BAI1E"}
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../src/tap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,iBAAiB,CAAC;AAKzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,CAAE,SAAQ,mBAAmB;IACjD,+BAA+B;IAC/B,GAAG,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,IAAI,CAAC,GAAG,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EACnC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GACtB,GAAG,CAAC,CAAC,CAAC,CAcR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,SAAS,YAAY,GAAG,YAAY,EAC3C,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,gBAI9B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,YAAY,GAAG,YAAY,EACzE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,gBAK9B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,SAAS,WAAW,GAAG,WAAW,EACrE,OAAO,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,eAK7B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,0BAI1E"}