@alloy-js/core 0.20.0-dev.3 → 0.20.0-dev.6

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

@@ -1,8 +1,8 @@
 import { isRef, shallowReactive } from "@vue/reactivity";
 import { effect, getContext, onCleanup } from "../reactivity.js";
-import { MemberScopeContext } from "../context/member-scope.js";
+import { MemberContext } from "../context/member-scope.js";
 import { ScopeContext } from "../context/scope.js";
-import { OutputSymbolFlags } from "./flags.js";
+import { formatSymbolName, trace, TracePhase } from "../tracer.js";
 export function takeSymbols(cb) {
   const context = getContext();
   context.takesSymbols = true;
@@ -21,6 +21,11 @@ export function takeSymbols(cb) {
   return context.takenSymbols;
 }
 export function emitSymbol(symbol) {
+  if (isRef(symbol)) {
+    trace(TracePhase.symbol.flow, () => `Emitting ref to symbol`);
+  } else {
+    trace(TracePhase.symbol.flow, () => `Emitting symbol ${formatSymbolName(symbol)}`);
+  }
   let symbolTaker;
   let context = getContext().owner;
   while (context) {
@@ -28,13 +33,15 @@ export function emitSymbol(symbol) {
       symbolTaker = context;
       break;
     }
-    if (context.context && (context.context[ScopeContext.id] || context.context[MemberScopeContext.id])) {
+    if (context.context && (context.context[ScopeContext.id] || context.context[MemberContext.id])) {
       // don't cross scope boundaries.
+      trace(TracePhase.symbol.flow, () => `Not emitting symbol across scope boundary`);
       break;
     }
     context = context.owner;
   }
   if (!symbolTaker) {
+    trace(TracePhase.symbol.flow, () => `No symbol taker found, not emitting`);
     return;
   }
   if (isRef(symbol)) {
@@ -53,6 +60,7 @@ export function emitSymbol(symbol) {
       }
     });
   } else {
+    trace(TracePhase.symbol.flow, () => `Emitting symbol ${formatSymbolName(symbol)} taken by ${symbolTaker.componentOwner?.name ?? "unknown component"}`);
     symbolTaker.takenSymbols.add(symbol);
     onCleanup(() => {
       context.takenSymbols.delete(symbol);
@@ -63,12 +71,19 @@ export function moveTakenMembersTo(baseSymbol) {
   const taken = takeSymbols();
   effect(() => {
     for (const symbol of taken) {
-      if (symbol.flags & OutputSymbolFlags.Transient) {
-        symbol.moveTo(baseSymbol);
+      if (symbol.isTransient) {
+        symbol.moveMembersTo(baseSymbol);
+      }
+      for (const refkey of symbol.refkeys) {
+        if (!baseSymbol.refkeys.includes(refkey)) {
+          baseSymbol.refkeys.push(refkey);
+        }
       }
     }
   });
 }
-export function instantiateTakenMembersTo(baseSymbol) {
-  takeSymbols(symbol => symbol.instantiateTo(baseSymbol));
+export function instantiateTakenMembersTo(baseSymbol, toSpaceKey, fromSpaceKey) {
+  takeSymbols(symbol => {
+    baseSymbol.type = symbol;
+  });
 }

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

@@ -1,12 +1,30 @@
 import { Ref, ShallowReactive } from "@vue/reactivity";
-import type { Children } from "../runtime/component.js";
+import type { Component } from "../runtime/component.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;
-};
+export interface SymbolSlot extends Component<{}> {
+    /**
+     * A ref for the set of symbols taken by this slot. Undefined when the Slot component
+     * has not been rendered yet.
+     */
+    ref: Ref<ShallowReactive<Set<OutputSymbol>> | undefined>;
+    /**
+     * A ref for the first symbol taken by this slot. Undefined when the Slot component
+     * has not been rendered yet or has not taken any symbols.
+     */
+    firstSymbol: Ref<OutputSymbol | undefined>;
+    /**
+     * Copy any members from taken symbols to the given symbol.
+     */
+    copyMembersTo(baseSymbol: OutputSymbol): void;
+    /**
+     * Move any members from transient taken symbols to the given symbol.
+     */
+    moveMembersTo(baseSymbol: OutputSymbol): void;
+}
+/**
+ * Create a component which accepts emitted symbols. The returned component has
+ * a `ref` property which is a ref to a reactive set of all symbols emitted by
+ * children of the component.
+ */
+export declare function createSymbolSlot(): SymbolSlot;
 //# sourceMappingURL=symbol-slot.d.ts.map

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

@@ -1 +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;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,wBAAgB,gBAAgB;YAGH;QAAE,QAAQ,EAAE,QAAQ,CAAA;KAAE;;gCAaP,YAAY;yBAYnB,YAAY;EAahD"}
+{"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;AAEnE,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,MAAM,WAAW,UAAW,SAAQ,SAAS,CAAC,EAAE,CAAC;IAC/C;;;OAGG;IACH,GAAG,EAAE,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IACzD;;;OAGG;IACH,WAAW,EAAE,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;IAE3C;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;IAE9C;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;CAC/C;AACD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAoD7C"}

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

@@ -1,6 +1,11 @@
 import { shallowRef } from "@vue/reactivity";
 import { effect, onCleanup } from "../reactivity.js";
 import { takeSymbols } from "./symbol-flow.js";
+/**
+ * Create a component which accepts emitted symbols. The returned component has
+ * a `ref` property which is a ref to a reactive set of all symbols emitted by
+ * children of the component.
+ */
 export function createSymbolSlot() {
   const symbolSlotRef = shallowRef();
   function SymbolSlot(props) {
@@ -12,23 +17,34 @@ export function createSymbolSlot() {
     return props.children;
   }
   SymbolSlot.ref = symbolSlotRef;
-  SymbolSlot.instantiateInto = baseSymbol => {
+  Object.defineProperty(SymbolSlot, "firstSymbol", {
+    get() {
+      const ref = shallowRef();
+      effect(() => {
+        ref.value = symbolSlotRef.value?.values().next().value;
+      });
+      return ref;
+    }
+  });
+  SymbolSlot.copyMembersTo = baseSymbol => {
     effect(() => {
       if (!symbolSlotRef.value) {
         return;
       }
       for (const symbol of symbolSlotRef.value) {
-        symbol.instantiateTo(baseSymbol);
+        symbol.copyMembersTo(baseSymbol);
       }
     });
   };
-  SymbolSlot.copyInto = baseSymbol => {
+  SymbolSlot.moveMembersTo = baseSymbol => {
     effect(() => {
       if (!symbolSlotRef.value) {
         return;
       }
       for (const symbol of symbolSlotRef.value) {
-        symbol.copyTo(baseSymbol);
+        if (symbol.isTransient) {
+          symbol.moveMembersTo(baseSymbol);
+        }
       }
     });
   };

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

@@ -1,14 +1,25 @@
-import type { NameConflictResolver } from "../binder.js";
+import type { Binder, NameConflictResolver } from "../binder.js";
 import { ReactiveUnionSet } from "../reactive-union-set.js";
-import type { OutputScope } from "./output-scope.js";
+import { Refkey } from "../refkey.js";
 import type { OutputSymbol } from "./output-symbol.js";
-export declare class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
-    private _namesToDeconflict;
-    private _nameConflictResolver?;
-    private _deconflictNames;
-    scope: OutputScope;
-    constructor(scope: OutputScope, options?: {
+export declare abstract class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
+    #private;
+    get binder(): Binder | undefined;
+    /**
+     * The key of this symbol table, e.g. "static" or "instance".
+     */
+    get key(): string;
+    /**
+     * The symbols defined within this scope, indexed by refkey.
+     */
+    get symbolsByRefkey(): ReadonlyMap<Refkey, OutputSymbol>;
+    get symbolNames(): ReadonlyMap<string, OutputSymbol>;
+    constructor(key: string, binder?: Binder, options?: {
         nameConflictResolver?: NameConflictResolver;
     });
+    moveTo(target: SymbolTable): void;
+    copyTo(target: SymbolTable, options?: {
+        createRefkeys?(sourceSymbol: OutputSymbol): Refkey[];
+    }): void;
 }
 //# sourceMappingURL=symbol-table.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"symbol-table.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAQ5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,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"}
+{"version":3,"file":"symbol-table.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAStC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,8BAAsB,WAAY,SAAQ,gBAAgB,CAAC,YAAY,CAAC;;IAmBtE,IAAI,MAAM,uBAET;IAID;;OAEG;IACH,IAAI,GAAG,WAEN;IAGD;;OAEG;IACH,IAAI,eAAe,sCAElB;IAGD,IAAI,WAAW,sCAEd;gBAGC,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;QACP,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;KACxC;IAmCR,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAejC,MAAM,CACJ,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE;QACP,aAAa,CAAC,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAC;KACjD,GACL,IAAI;CAgBR"}

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

@@ -1,33 +1,82 @@
 import { ReactiveUnionSet } from "../reactive-union-set.js";
 import { queueJob } from "../scheduler.js";
-import { formatScopeName, formatSymbolName, trace, TracePhase } from "../tracer.js";
+import { formatSymbolName, formatSymbolTableName, 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);
+  #namesToDeconflict = new Set();
+  #nameConflictResolver;
+  #deconflictNames = () => {
+    for (const name of this.#namesToDeconflict) {
+      const conflictedSymbols = [...this].filter(sym => sym.originalName === name && !sym.ignoreNameConflict);
+      if (this.#nameConflictResolver) {
+        this.#nameConflictResolver(name, conflictedSymbols);
       } else {
         defaultConflictHandler(name, conflictedSymbols);
       }
-      this._namesToDeconflict.delete(name);
+      this.#namesToDeconflict.delete(name);
     }
   };
-  constructor(scope, options = {}) {
+  #binder;
+  get binder() {
+    return this.#binder;
+  }
+  #key;
+
+  /**
+   * The key of this symbol table, e.g. "static" or "instance".
+   */
+  get key() {
+    return this.#key;
+  }
+  #symbolsByRefkey;
+  /**
+   * The symbols defined within this scope, indexed by refkey.
+   */
+  get symbolsByRefkey() {
+    return this.#symbolsByRefkey;
+  }
+  #symbolNames;
+  get symbolNames() {
+    return this.#symbolNames;
+  }
+  constructor(key, binder, options = {}) {
     super({
       onAdd: symbol => {
-        trace(TracePhase.symbol.addToScope, () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`);
-        this._namesToDeconflict.add(symbol.name);
-        queueJob(this._deconflictNames);
+        trace(TracePhase.symbol.addToScope, () => `${formatSymbolName(symbol)} added to ${formatSymbolTableName(this)}`);
+        this.#namesToDeconflict.add(symbol.name);
+        queueJob(this.#deconflictNames);
         return symbol;
       },
-      onDelete(symbol) {
-        trace(TracePhase.symbol.removeFromScope, () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`);
+      onDelete: symbol => {
+        trace(TracePhase.symbol.removeFromScope, () => `${formatSymbolName(symbol)} removed from ${formatSymbolTableName(this)}`);
+      }
+    });
+    this.#nameConflictResolver = options.nameConflictResolver ?? binder?.nameConflictResolver;
+    this.#binder = binder;
+    this.#key = key;
+    this.#symbolsByRefkey = this.createIndex(s => s.refkeys);
+    this.#symbolNames = this.createIndex(s => {
+      return s.name;
+    });
+  }
+  moveTo(target) {
+    trace(TracePhase.scope.moveSymbols, () => `${formatSymbolTableName(this)} -> ${formatSymbolTableName(target)}`);
+    target.addSubset(this, {
+      onAdd: symbol => {
+        symbol.spaces = [target];
+        return symbol;
+      }
+    });
+  }
+  copyTo(target, options = {}) {
+    trace(TracePhase.scope.copySymbols, () => `${formatSymbolTableName(this)} copied to ${formatSymbolTableName(target)}`);
+    target.addSubset(this, {
+      onAdd: symbol => {
+        const copy = symbol.copy();
+        copy.spaces = [target];
+        copy.refkeys = options.createRefkeys?.(symbol) ?? [];
+        return copy;
       }
     });
-    this.scope = scope;
-    this._nameConflictResolver = options.nameConflictResolver;
   }
 }
 

package/dist/src/tracer.d.ts

@@ -1,6 +1,7 @@
-import type { Refkey } from "./refkey.js";
+import { type Refkey } from "./refkey.js";
 import { type OutputScope } from "./symbols/output-scope.js";
 import { type OutputSymbol } from "./symbols/output-symbol.js";
+import { SymbolTable } from "./symbols/symbol-table.js";
 export declare const TracePhase: {
     readonly scope: {
         readonly update: {
@@ -30,6 +31,15 @@ export declare const TracePhase: {
                 readonly b: 100;
             };
         };
+        readonly moveSymbols: {
+            readonly area: "scope";
+            readonly subarea: "moveSymbols";
+            readonly bg: {
+                readonly r: 0;
+                readonly g: 100;
+                readonly b: 100;
+            };
+        };
     };
     readonly symbol: {
         readonly update: {
@@ -226,13 +236,15 @@ interface TextFormat {
  */
 export declare function formatSymbolName(symbol: OutputSymbol): string;
 export declare function formatSymbol(symbol: OutputSymbol): string;
-export declare function formatScopeName(scope: OutputScope): string;
+export declare function formatSpaceSymbols(space: SymbolTable): string;
+export declare function formatScopeName(scope: OutputScope | undefined): string;
+export declare function formatSymbolTableName(table: SymbolTable): string;
 /**
  * Format an OutputScope for display, showing information in a concise format
  * @param scope The scope to format
  * @returns A formatted string representation of the scope
  */
-export declare function formatScope(scope: OutputSymbol["scope"]): string;
+export declare function formatScope(scope: OutputScope): string;
 export declare function formatRefkeys(refkeys: Refkey[] | Refkey | undefined): string;
 export {};
 //# sourceMappingURL=tracer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../src/tracer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAC;AA0B/D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHb,CAAC;AAEX,UAAU,UAAW,SAAQ,UAAU;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAUD,wBAAgB,KAAK,CACnB,KAAK,EAAE,UAAU,EACjB,EAAE,EAAE,MAAM,MAAM,EAChB,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,QA4BpC;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,MAAM,QA8B9D;AAED,UAAU,KAAK;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4CAA4C;AAC5C,UAAU,UAAU;IAClB,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAuDD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAQ7D;AAiBD,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAoDzD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAc1D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,MAAM,CAoDhE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAUnE"}
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../src/tracer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAK7D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA0BxD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHb,CAAC;AAEX,UAAU,UAAW,SAAQ,UAAU;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAUD,wBAAgB,KAAK,CACnB,KAAK,EAAE,UAAU,EACjB,EAAE,EAAE,MAAM,MAAM,EAChB,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,QA4BpC;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,MAAM,QA8B9D;AAED,UAAU,KAAK;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4CAA4C;AAC5C,UAAU,UAAU;IAClB,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAqCD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAQ7D;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAoCzD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,UAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAYtE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAahE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAwCtD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAUnE"}

package/dist/src/tracer.js

@@ -1,7 +1,7 @@
 import { effect } from "@vue/reactivity";
 import { untrack } from "./reactivity.js";
+import { isMemberRefkey } from "./refkey.js";
 import { scheduler } from "./scheduler.js";
-import { OutputScopeFlags, OutputSymbolFlags } from "./symbols/flags.js";
 // enable tracing for specific phases using a comma separated list of
 // dotted identifiers, e.g. `scope.update,symbol.create`.
 const traceEnv = process.env.ALLOY_TRACE ?? "";
@@ -46,6 +46,15 @@ export const TracePhase = {
         g: 100,
         b: 100
       }
+    },
+    moveSymbols: {
+      area: "scope",
+      subarea: "moveSymbols",
+      bg: {
+        r: 0,
+        g: 100,
+        b: 100
+      }
     }
   },
   symbol: {
@@ -316,16 +325,6 @@ function colorText(text, fmt) {
   return `${prefix}${text}${reset}`;
 }
 
-/**
- * Format flag values in a concise way, showing only the flags that are set
- * @param flags The numeric flags value to format
- * @param flagEnum The enum containing flag definitions
- * @returns An array of flag names that are set
- */
-function formatFlags(flags, flagEnum) {
-  return Object.entries(flagEnum).filter(([name, value]) => typeof value === "number" && value !== 0 && (flags & value) === value).map(([name]) => name);
-}
-
 /**
  * Format a symbol name with its ID in a blue-green color
  * @param symbol The symbol to format
@@ -340,18 +339,6 @@ export function formatSymbolName(symbol) {
     }
   });
 }
-
-/**
- * Format the symbols in a member scope, showing their names and IDs
- * @param scope The member scope containing the symbols to format
- * @returns A formatted string representation of the member scope symbols
- */
-function formatMemberScopeSymbols(scope) {
-  if (!scope || scope.symbols.size === 0) {
-    return "none";
-  }
-  return Array.from(scope.symbols).map(symbol => formatSymbolName(symbol)).join(", ");
-}
 export function formatSymbol(symbol) {
   // Base display with name and ID
   let result = formatSymbolName(symbol);
@@ -368,29 +355,15 @@ export function formatSymbol(symbol) {
     }));
   }
 
-  // Show only enabled flags
-  const flagsInfo = formatFlags(symbol.flags, OutputSymbolFlags);
-  if (flagsInfo.length > 0) {
-    details.push(`  flags: ${flagsInfo.join(", ")}`);
-  }
-
   // Show scope info with formatted name
   if (symbol.scope) {
     details.push(untrack(() => `  scope: ${formatScopeName(symbol.scope)}`));
   }
-
-  // Show member scopes if present
-  if (symbol.instanceMemberScope) {
-    untrack(() => {
-      const memberCount = symbol.instanceMemberScope.symbols.size;
-      details.push(`  instance members: ${memberCount} - ${formatMemberScopeSymbols(symbol.instanceMemberScope)}`);
-    });
+  for (const space of symbol.memberSpaces) {
+    details.push(untrack(() => formatSpaceSymbols(space)));
   }
-  if (symbol.staticMemberScope) {
-    untrack(() => {
-      const memberCount = symbol.staticMemberScope.symbols.size;
-      details.push(`  static members: ${memberCount} - ${formatMemberScopeSymbols(symbol.staticMemberScope)}`);
-    });
+  if (symbol.ownerSymbol) {
+    details.push(untrack(() => `  ownerSymbol: ${formatSymbolName(symbol.ownerSymbol)}`));
   }
 
   // Show all refkeys with proper formatting
@@ -402,18 +375,31 @@ export function formatSymbol(symbol) {
   }
   return result;
 }
+export function formatSpaceSymbols(space) {
+  return `  ${space.key} symbols (${space.size}): ${[...space].map(s => s.name).join(", ")}`;
+}
 export function formatScopeName(scope) {
-  let text = colorText(`${scope.name}[${scope.id}]`, {
+  if (!scope) {
+    return "no scope";
+  }
+  return colorText(`${scope.name}[${scope.id}]`, {
     fg: {
       r: 0,
       g: 150,
       b: 50
     }
   });
-  if (scope.owner) {
-    text += untrack(() => ` of ${formatSymbolName(scope.owner)}`);
-  }
-  return text;
+}
+export function formatSymbolTableName(table) {
+  // avoid instance of checks here in order to not create circular module imports.
+  const name = "symbol" in table ? formatSymbolName(table.symbol) : formatScopeName(table.scope);
+  return colorText(`${name}:${table.key}`, {
+    fg: {
+      r: 0,
+      g: 125,
+      b: 25
+    }
+  });
 }
 
 /**
@@ -445,32 +431,21 @@ export function formatScope(scope) {
       }
     }));
   }
-  // Show only enabled flags
-  const flagsInfo = formatFlags(scope.flags, OutputScopeFlags);
-  if (flagsInfo.length > 0) {
-    details.push(`  flags: ${flagsInfo.join(", ")}`);
-  }
-
-  // Show symbol count
-  const symbolCount = scope.symbols.size;
-  if (symbolCount > 0) {
-    details.push(`  symbols: ${symbolCount}`);
-  }
 
   // Show parent scope if present
   if (scope.parent) {
     details.push(`  parent: ${formatScopeName(scope.parent)}`);
   }
 
-  // Show owner if present (for member scopes)
-  if (scope.owner) {
-    details.push(`  owner: ${formatSymbolName(scope.owner)}`);
-  }
-
   // Show child scopes if present
   if (scope.children && scope.children.size > 0) {
     details.push(`  children: ${scope.children.size}`);
   }
+
+  // Show declaration spaces
+  for (const space of scope.spaces) {
+    details.push(`  ${untrack(() => formatSpaceSymbols(space))}`);
+  }
   if (details.length > 0) {
     result += "\n" + details.join("\n");
   }
@@ -486,7 +461,8 @@ export function formatRefkeys(refkeys) {
   return formatRefkey(refkeys);
 }
 function formatRefkey(refkey) {
-  return colorText(`refkey[${refkey.key}]`, {
+  const text = isMemberRefkey(refkey) ? `memberRefkey[${formatRefkey(refkey.base)} -> ${formatRefkey(refkey.member)}]` : `refkey[${refkey.key}]`;
+  return colorText(text, {
     fg: {
       r: 150,
       g: 0,

package/dist/src/utils.d.ts

@@ -80,7 +80,7 @@ export interface OutputVisitor {
  * @param sourceDirectory - The root directory to traverse.
  * @param visitor - The visitor to call for each file and directory.
  */
-export declare function traverseOutput(sourceDirectory: OutputDirectory, visitor: OutputVisitor): void;
+export declare function traverseOutput(sourceDirectory: OutputDirectory, visitor: OutputVisitor): Promise<void>;
 /**
  * Convert a list of props to a joiner and ender for use in {@link (mapJoin:1)}.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAEL,aAAa,EAMd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAU,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC;IAElB;;;;OAIG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;IAEjB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,EAAE,CAAC;AACpD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC,EACpC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAClC,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,EAAE,CAAC;AAmHpD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EACrC,GAAG,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtB,OAAO,GAAE,WAAgB,GACxB,QAAQ,CAmBV;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AACD;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,QAAQ,EAClB,OAAO,GAAE,eAAoB,GAC5B,MAAM,QAAQ,CAsBhB;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,QAAQ,EAClB,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,EAAE,CASZ;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,mEAQ/D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,8DAQlE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,cAEvD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,IAAI,gBAAgB,CAEvE;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IACjD,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,aAAa,QAUvB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,CAuC5E"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAEL,aAAa,EAMd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAU,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC;IAElB;;;;OAIG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;IAEjB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,EAAE,CAAC;AACpD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC,EACpC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAClC,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,EAAE,CAAC;AAmHpD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EACrC,GAAG,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtB,OAAO,GAAE,WAAgB,GACxB,QAAQ,CAmBV;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AACD;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,QAAQ,EAClB,OAAO,GAAE,eAAoB,GAC5B,MAAM,QAAQ,CAsBhB;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,QAAQ,EAClB,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,EAAE,CASZ;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,mEAQ/D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,8DAQlE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,cAEvD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,IAAI,gBAAgB,CAEvE;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IACjD,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,aAAa,iBAUvB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,CAuC5E"}

package/dist/src/utils.js

@@ -211,13 +211,13 @@ export function isKeyedChild(child) {
  * @param sourceDirectory - The root directory to traverse.
  * @param visitor - The visitor to call for each file and directory.
  */
-export function traverseOutput(sourceDirectory, visitor) {
-  visitor.visitDirectory(sourceDirectory);
+export async function traverseOutput(sourceDirectory, visitor) {
+  await visitor.visitDirectory(sourceDirectory);
   for (const item of sourceDirectory.contents) {
     if (item.kind === "directory") {
-      traverseOutput(item, visitor);
+      await traverseOutput(item, visitor);
     } else {
-      visitor.visitFile(item);
+      await visitor.visitFile(item);
     }
   }
 }

package/dist/src/write-output.d.ts

@@ -3,5 +3,5 @@ import { OutputDirectory } from "./render.js";
  * Write the output from {@link render} to the file system.
  *
  */
-export declare function writeOutput(output: OutputDirectory, basePath?: string): Promise<void[]>;
+export declare function writeOutput(output: OutputDirectory, basePath?: string): Promise<void>;
 //# sourceMappingURL=write-output.d.ts.map

package/dist/src/write-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../src/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,eAAe,EACvB,QAAQ,GAAE,MAAW,mBAoDtB"}
+{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../src/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,eAAe,EACvB,QAAQ,GAAE,MAAW,iBAwCtB"}