@hydranium/protocol 1.0.0-next.32 → 1.0.0-next.320

package/src/testing/data-doubles.ts

@@ -33,9 +33,19 @@
 
 import { Emitter, type MessageConnection } from 'vscode-jsonrpc';
 import type { DataPort } from '../client/data-port';
+import { DATA_CLIENT_PROTOCOL_METHODS } from '../data/data-protocol-methods';
 import type { DataClientProtocol } from '../data/data-server-protocol';
-import type { ProjectsChangedEvent, TransferDocumentSavedEvent, TransferDocumentUpdatedEvent } from '../data/events';
+import type {
+   ProjectsChangedEvent,
+   TransferDocumentDeletedEvent,
+   TransferDocumentDirtyChangedEvent,
+   TransferDocumentSavedEvent,
+   TransferDocumentsBuiltEvent,
+   TransferDocumentUpdatedEvent
+} from '../data/events';
+import type { Logger } from '../logger';
 import type { ResolvedMessage } from '../messages/primitives';
+import type { RpcProxyLifecycle } from '../rpc/create-rpc-proxy';
 import type { Project } from '../project';
 import type { TransferDiagnostic } from '../transfer-diagnostic';
 import type { TransferElement } from '../transfer-element';
@@ -50,15 +60,14 @@ export interface FakeDataPortOptions {
     *
     * Throwing (or rejecting) here is the transport-construction failure path,
     * which the consumer surfaces through {@link FakeDataPort.reported}.
+    *
+    * The double disposes none of these connections and goes on connecting
+    * after its dispose, where a real port releases its connection and refuses:
+    * the test owns them.
     */
    connect(): MessageConnection | Promise<MessageConnection>;
-   /**
-    * Stable client identity. Defaults to `'fake-data-port'`, which avoids the
-    * three sentinels the framework reserves (`'language-client'`, `'unknown'`,
-    * `'revert-on-close'`); override it when a test needs two distinguishable
-    * clients on one server.
-    */
-   clientId?: string;
+   /** The port's {@link DataPort.logger}. */
+   logger?: Logger;
 }
 
 /** A {@link DataPort} that records what passed through it. */
@@ -101,9 +110,9 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    const reported: { error: unknown; message: ResolvedMessage }[] = [];
    const disposeEmitter = new Emitter<void>();
    return {
-      clientId: options.clientId ?? 'fake-data-port',
       connections,
       reported,
+      logger: options.logger,
       onDispose: disposeEmitter.event,
       async connect(): Promise<MessageConnection> {
          const connection = await options.connect();
@@ -122,26 +131,78 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    };
 }
 
+type UpperLetter =
+   | 'A'
+   | 'B'
+   | 'C'
+   | 'D'
+   | 'E'
+   | 'F'
+   | 'G'
+   | 'H'
+   | 'I'
+   | 'J'
+   | 'K'
+   | 'L'
+   | 'M'
+   | 'N'
+   | 'O'
+   | 'P'
+   | 'Q'
+   | 'R'
+   | 'S'
+   | 'T'
+   | 'U'
+   | 'V'
+   | 'W'
+   | 'X'
+   | 'Y'
+   | 'Z';
+
+/**
+ * A notification name `TClient` adds to {@link DataClientProtocol}. Limited to
+ * `on` plus a letter A–Z, the names the proxy sends as notifications; any other
+ * name would be bound as a request. The {@link RpcProxyLifecycle} names are
+ * excluded too: the proxy returns its own events for them and sends nothing.
+ */
+export type AdditionalClientMethod<TClient> = Exclude<keyof TClient, keyof DataClientProtocol<TransferElement> | keyof RpcProxyLifecycle> &
+   `on${UpperLetter}${string}`;
+
 /** A {@link DataClientProtocol} plus the arrays it records into. */
 export interface CapturingDataClient<
    TTransfer extends TransferElement,
    TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TClient extends DataClientProtocol<TTransfer, TDiagnostic, TProject> = DataClientProtocol<TTransfer, TDiagnostic, TProject>
 > {
    /** The client to hand to a `DataSession` or bind as an RPC `localTarget`. */
-   readonly client: DataClientProtocol<TTransfer, TDiagnostic, TProject>;
+   readonly client: TClient;
    /** Every `onDocumentUpdated` event, in arrival order. */
    readonly updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[];
    /** Every `onDocumentSaved` event, in arrival order. */
    readonly saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[];
+   /** Every `onDocumentDirtyChanged` event, in arrival order. */
+   readonly dirtyChanges: TransferDocumentDirtyChangedEvent[];
+   /** Every `onDocumentDeleted` event, in arrival order. */
+   readonly deletions: TransferDocumentDeletedEvent[];
+   /** Every `onDocumentsBuilt` event, in arrival order. */
+   readonly builds: TransferDocumentsBuiltEvent[];
    /** Every `onProjectsChanged` event, in arrival order. */
    readonly projectsChanges: ProjectsChangedEvent<TProject>[];
+   /**
+    * Every event of each additional client method, keyed by method, in arrival
+    * order. A method of `TClient` left out of `additionalClientMethods` has no
+    * entry.
+    */
+   readonly additionalNotifications: {
+      readonly [K in AdditionalClientMethod<TClient>]: TClient[K] extends (event: infer TEvent) => void ? TEvent[] : never;
+   };
 }
 
 /**
  * A {@link DataClientProtocol} that records every notification it receives.
  *
- * Recording ALL THREE channels even when a suite reads one is deliberate: an
+ * Recording EVERY channel even when a suite reads one is deliberate: an
  * event delivered on the wrong channel is a real defect of the data head, and a
  * double that drops the other two turns it into silence on the one being
  * watched.
@@ -150,31 +211,92 @@ export interface CapturingDataClient<
  * the corresponding array stays empty — that is what makes an override usable
  * as a barrier (rejecting, counting differently, throwing) rather than only as
  * a spy.
+ *
+ * `additionalClientMethods` names the notifications `TClient` adds to
+ * {@link DataClientProtocol}. Each is recorded and overridable the same way;
+ * one left out is not on the client at all, and overriding it throws, since
+ * nothing would call the override.
  */
 export function makeCapturingDataClient<
    TTransfer extends TransferElement,
    TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
-   TProject extends Project = Project
->(overrides: Partial<DataClientProtocol<TTransfer, TDiagnostic, TProject>> = {}): CapturingDataClient<TTransfer, TDiagnostic, TProject> {
+   TProject extends Project = Project,
+   TClient extends DataClientProtocol<TTransfer, TDiagnostic, TProject> = DataClientProtocol<TTransfer, TDiagnostic, TProject>
+>(
+   overrides: Partial<TClient> = {},
+   additionalClientMethods: readonly AdditionalClientMethod<TClient>[] = []
+): CapturingDataClient<TTransfer, TDiagnostic, TProject, TClient> {
+   const bound = new Set<string>([...DATA_CLIENT_PROTOCOL_METHODS, ...additionalClientMethods]);
+   for (const name of Object.keys(overrides)) {
+      if (!bound.has(name)) {
+         throw new Error(
+            `Override '${name}' is neither a DataClientProtocol method nor listed in additionalClientMethods, so nothing would call it.`
+         );
+      }
+   }
+   const frameworkOverrides: Partial<DataClientProtocol<TTransfer, TDiagnostic, TProject>> = overrides;
    const updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[] = [];
    const saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[] = [];
+   const dirtyChanges: TransferDocumentDirtyChangedEvent[] = [];
+   const deletions: TransferDocumentDeletedEvent[] = [];
+   const builds: TransferDocumentsBuiltEvent[] = [];
    const projectsChanges: ProjectsChangedEvent<TProject>[] = [];
-   const client: DataClientProtocol<TTransfer, TDiagnostic, TProject> = {
+   const frameworkClient: DataClientProtocol<TTransfer, TDiagnostic, TProject> = {
       onDocumentUpdated:
-         overrides.onDocumentUpdated ??
+         frameworkOverrides.onDocumentUpdated ??
          (event => {
             updates.push(event);
          }),
       onDocumentSaved:
-         overrides.onDocumentSaved ??
+         frameworkOverrides.onDocumentSaved ??
          (event => {
             saves.push(event);
          }),
+      onDocumentDirtyChanged:
+         frameworkOverrides.onDocumentDirtyChanged ??
+         (event => {
+            dirtyChanges.push(event);
+         }),
+      onDocumentDeleted:
+         frameworkOverrides.onDocumentDeleted ??
+         (event => {
+            deletions.push(event);
+         }),
+      onDocumentsBuilt:
+         frameworkOverrides.onDocumentsBuilt ??
+         (event => {
+            builds.push(event);
+         }),
       onProjectsChanged:
-         overrides.onProjectsChanged ??
+         frameworkOverrides.onProjectsChanged ??
          (event => {
             projectsChanges.push(event);
          })
    };
-   return { client, updates, saves, projectsChanges };
+   const additionalNotifications: Record<string, unknown[]> = {};
+   const additionalHandlers: Record<string, unknown> = {};
+   for (const method of additionalClientMethods) {
+      const events: unknown[] = [];
+      additionalNotifications[method] = events;
+      additionalHandlers[method] =
+         overrides[method] ??
+         ((event: unknown) => {
+            events.push(event);
+         });
+   }
+   return {
+      client: { ...frameworkClient, ...additionalHandlers } as unknown as TClient,
+      updates,
+      saves,
+      dirtyChanges,
+      deletions,
+      builds,
+      projectsChanges,
+      additionalNotifications: additionalNotifications as CapturingDataClient<
+         TTransfer,
+         TDiagnostic,
+         TProject,
+         TClient
+      >['additionalNotifications']
+   };
 }

package/src/testing/fake-clock.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Clock, type Stopwatch, type Timed } from '../clock';
+import { type Clock, type Stopwatch, SystemClock } from '../clock';
 import { Disposable } from '../util';
 
 /** A {@link Clock} whose time only moves when the test calls {@link FakeClock.advance}. */
@@ -17,9 +17,19 @@ export interface FakeClock extends Clock {
     * whose deadline falls within the window — in chronological order, each at
     * its own deadline (so `now()` inside a callback reads the fire instant, not
     * the advance target). Timers scheduled by a callback fire too if they fall
-    * within the same window.
+    * within the same window. A {@link Clock.raceTimer} over a promise that
+    * settles through a chain still pending loses to the timer, so let that
+    * chain settle before advancing.
     */
    advance(ms: number): void;
+   /**
+    * Move `now()` by `ms`, backwards when negative, leaving stopwatches and
+    * timers where they are: the wall-clock step a time sync or a manual change makes,
+    * which a duration taken from two `now()` readings gets wrong.
+    */
+   jumpWallClock(ms: number): void;
+   /** How many {@link Clock.setTimer} timers have neither fired nor been disposed. */
+   pendingTimers(): number;
 }
 
 interface FakeTimer {
@@ -35,72 +45,90 @@ interface FakeTimer {
  * (`Date.now` for `now()`, `performance.now()` for the stopwatch); the fake
  * collapses them onto ONE virtual time axis, so a single
  * {@link FakeClock.advance} drives `now()`, every live stopwatch's elapsed, and
- * any due timer together.
+ * any due timer together; only {@link FakeClock.jumpWallClock} pulls `now()`
+ * off that axis.
  *
  * Server-free and DI-free — lives in `@hydranium/protocol/testing` so every
  * head can bind it without pulling in a server package.
+ *
+ * The clock is a `SystemClock` with its time replaced, so its methods live on
+ * its prototype and a spread of it carries none of them. Replace one by
+ * assigning it onto the clock, or layer over the clock with `Object.create`.
  */
 export function makeFakeClock(options: { now?: number } = {}): FakeClock {
-   let current = options.now ?? 0;
-   const timers: FakeTimer[] = [];
+   return new VirtualClock(options.now ?? 0);
+}
+
+/**
+ * A `SystemClock` whose time, stopwatches and timers read one virtual axis, so
+ * the `measure` and `raceTimer` it inherits run on that axis too.
+ */
+class VirtualClock extends SystemClock implements FakeClock {
+   protected readonly timers: FakeTimer[] = [];
+   /** What {@link jumpWallClock} has added to `now()`. */
+   protected wallClockOffset = 0;
 
-   const makeStopwatch = (): Stopwatch => {
-      const start = current;
-      let lastLap = current;
+   constructor(protected current: number) {
+      super();
+   }
+
+   override now(): number {
+      return this.current + this.wallClockOffset;
+   }
+
+   jumpWallClock(ms: number): void {
+      this.wallClockOffset += ms;
+   }
+
+   override setTimer(callback: () => void, ms: number): Disposable {
+      const timer: FakeTimer = { at: this.current + ms, callback, disposed: false, fired: false };
+      this.timers.push(timer);
+      return Disposable.create(() => {
+         timer.disposed = true;
+      });
+   }
+
+   override stopwatch(): Stopwatch {
+      const read = (): number => this.current;
+      const start = read();
+      let lastLap = start;
       let stopped: number | undefined;
       return {
          get elapsedMs(): number {
-            return (stopped ?? current) - start;
+            return (stopped ?? read()) - start;
          },
          lap(): number {
-            const at = stopped ?? current;
+            const at = stopped ?? read();
             const split = at - lastLap;
             lastLap = at;
             return split;
          },
          stop(): number {
-            if (stopped === undefined) {
-               stopped = current;
-            }
+            stopped ??= read();
             return stopped - start;
          }
       };
-   };
+   }
 
-   return {
-      now: () => current,
-      setTimer(callback: () => void, ms: number): Disposable {
-         const timer: FakeTimer = { at: current + ms, callback, disposed: false, fired: false };
-         timers.push(timer);
-         return Disposable.create(() => {
-            timer.disposed = true;
-         });
-      },
-      stopwatch: makeStopwatch,
-      measure: (<T>(callback: () => T | Promise<T>): Timed<T> | Promise<Timed<T>> => {
-         const stopwatch = makeStopwatch();
-         const result = callback();
-         if (result instanceof Promise) {
-            return (result as Promise<T>).then(value => ({ result: value, elapsedMs: stopwatch.elapsedMs }));
-         }
-         return { result: result as T, elapsedMs: stopwatch.elapsedMs };
-      }) as Clock['measure'],
-      advance(ms: number): void {
-         const target = current + ms;
-         // Fire due timers one at a time, re-scanning after each so a callback
-         // that schedules a nearer timer still fires within this window.
-         for (;;) {
-            const next = timers
-               .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
-               .sort((left, right) => left.at - right.at)[0];
-            if (!next) {
-               break;
-            }
-            current = next.at;
-            next.fired = true;
-            next.callback();
+   pendingTimers(): number {
+      return this.timers.filter(timer => !timer.disposed && !timer.fired).length;
+   }
+
+   advance(ms: number): void {
+      const target = this.current + ms;
+      // Fire due timers one at a time, re-scanning after each so a callback
+      // that schedules a nearer timer still fires within this window.
+      for (;;) {
+         const next = this.timers
+            .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
+            .sort((left, right) => left.at - right.at)[0];
+         if (!next) {
+            break;
          }
-         current = target;
+         this.current = next.at;
+         next.fired = true;
+         next.callback();
       }
-   };
+      this.current = target;
+   }
 }

package/src/testing/index.ts

@@ -11,13 +11,13 @@
 // primitives: `makeFakeClock` (deterministic `Clock` double on one virtual time
 // axis), `waitFor` / `tick`, the client-side data-head doubles
 // (`makeFakeDataPort` / `makeCapturingDataClient`), the translation-catalogue
-// audit (`flattenCatalogue` / `findUndeclaredCodes` / `findSharedCodes`), and
-// the `Harness` marker
+// audit (`flattenCatalogue` / `findUndeclaredCodes` / `findSharedCodes`), the
+// transfer-node builder (`makeTransferNodeBuilder`), and the `Harness` marker
 // interface every framework harness extends. Kept out of the main barrel so production bundles don't pull
 // the test scaffolding in by default; adopters opt in by importing from
 // `@hydranium/protocol/testing`.
 //
-// Neutrality is gated (`scripts/check-neutral-bundles.mjs`), which is why the
+// Neutrality is gated (`scripts/check-neutral-bundles.mts`), which is why the
 // duplex transports are NOT here: a `PassThrough` pair is in their exported
 // type, so they cannot be made portable and live at `./testing/node` instead.
 // The same rule the package surface uses — the portable name is the short one.
@@ -26,4 +26,5 @@ export * from './catalogue-audit';
 export * from './data-doubles';
 export * from './fake-clock';
 export * from './harness';
+export * from './transfer-node-builder';
 export * from './wait-for';

package/src/testing/node/duplex-connection.ts

@@ -32,8 +32,9 @@ export function makeDuplexConnectionPair(): DuplexConnectionPair {
    const pair = makeDuplexStreamPair();
    const { clientToServer, serverToClient } = pair;
 
-   const left = createMessageConnection(new StreamMessageReader(serverToClient), new StreamMessageWriter(clientToServer));
-   const right = createMessageConnection(new StreamMessageReader(clientToServer), new StreamMessageWriter(serverToClient));
+   // `console`, so a protocol fault on either end shows in the test's output.
+   const left = createMessageConnection(new StreamMessageReader(serverToClient), new StreamMessageWriter(clientToServer), console);
+   const right = createMessageConnection(new StreamMessageReader(clientToServer), new StreamMessageWriter(serverToClient), console);
 
    left.listen();
    right.listen();

package/src/testing/node/index.ts

@@ -8,8 +8,7 @@
  ********************************************************************************/
 
 // Subpath barrel for `@hydranium/protocol/testing/node` — the test transports
-// that need a Node runtime: a crossed `PassThrough` pair and the in-process
-// `MessageConnection` bridge over it.
+// that need a Node runtime.
 //
 // Separate from `./testing` because a `PassThrough` is in `DuplexStreamPair`'s
 // exported type and `StreamMessageReader` comes from `vscode-jsonrpc/node`, so
@@ -20,3 +19,4 @@
 
 export * from './duplex-connection';
 export * from './duplex-stream';
+export * from './message-port-pair';

package/src/testing/node/message-port-pair.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { MessageChannel } from 'node:worker_threads';
+import type { TransferredMessagePort } from '../../client/post-message-transport';
+
+/**
+ * The two ends of a `worker_threads` `MessageChannel`, typed as the transferred
+ * browser ports `createMessagePortTransport` takes. Node's port clones and keeps
+ * order as a browser's does, which is what lets a headless test stand in for a
+ * worker.
+ *
+ * `dispose` closes both ports. Node reports that as a close and a browser port
+ * reports nothing, so a test that asserts on a close does so before teardown.
+ */
+export interface MessagePortPair {
+   readonly port1: TransferredMessagePort;
+   readonly port2: TransferredMessagePort;
+   dispose(): void;
+}
+
+export function makeMessagePortPair(): MessagePortPair {
+   const channel = new MessageChannel();
+   return {
+      // Node's port satisfies the structural type at runtime; the cast records
+      // one platform's port standing in for the other's.
+      port1: channel.port1 as unknown as TransferredMessagePort,
+      port2: channel.port2 as unknown as TransferredMessagePort,
+      dispose(): void {
+         channel.port1.close();
+         channel.port2.close();
+      }
+   };
+}

package/src/testing/transfer-node-builder.ts

@@ -0,0 +1,107 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import type { TransferElement } from '../transfer-element';
+import type { ConcreteTypeName, SingleTypeName } from '../types';
+
+/**
+ * The per-type constant the generated transfer model emits under each type's
+ * name, as Langium does for the AST. Its `$type` literal picks the interface
+ * out of the builder's type map.
+ */
+export interface TransferTypeConstant<TType extends string = string> {
+   readonly $type: TType;
+}
+
+/**
+ * What {@link makeTransferNodeBuilder} reads from a reflection: each type's
+ * grammar properties and their defaults. The generated
+ * `<LanguageId>TransferReflection` satisfies it without importing it, and
+ * keeps the literal type of its `types` so the builder can tell which fields
+ * the grammar defaults.
+ */
+export interface TransferReflection {
+   getTypeMetaData(type: string): { readonly properties: Readonly<Record<string, { readonly defaultValue?: unknown }>> };
+}
+
+/** The properties of `TType` that `TReflection`'s literal `types` gives a `defaultValue`; none for a reflection typed only as the interface. */
+type DefaultedKeys<TReflection, TType> = TReflection extends { readonly types: infer Types }
+   ? TType extends keyof Types
+      ? Types[TType] extends { readonly properties: infer Properties }
+         ? { [K in keyof Properties]: Properties[K] extends { readonly defaultValue: unknown } ? K : never }[keyof Properties]
+         : never
+      : never
+   : never;
+
+/**
+ * Init payload of a {@link TransferNodeBuilder}: every field of `T` as its
+ * interface declares it, except that the fields named by `TDefaulted`, which
+ * the grammar defaults, are optional. `$type` comes from the constant.
+ */
+export type TransferNodeInit<T extends TransferElement, TDefaulted extends PropertyKey = never> = Omit<T, '$type' | TDefaulted> &
+   Partial<Pick<T, Extract<TDefaulted, keyof T>>>;
+
+/**
+ * Transfer-node factory bound to a grammar's type map, the transfer twin of
+ * core's `AstNodeBuilder`. `TMap` is the generated `<LanguageId>TransferTypes`,
+ * `TReflection` the type of the generated reflection.
+ */
+export interface TransferNodeBuilder<TMap, TReflection extends TransferReflection = TransferReflection> {
+   /** A complete node: the grammar's defaults, then `init`. */
+   <TType extends ConcreteTypeName<TMap>>(
+      typeConstant: TransferTypeConstant<TType> & SingleTypeName<TType>,
+      init: TransferNodeInit<Extract<TMap[TType], TransferElement>, DefaultedKeys<TReflection, TType>>
+   ): Extract<TMap[TType], TransferElement>;
+   /**
+    * A node holding only `init`, with no defaults filled, typed as the
+    * incomplete node it is.
+    */
+   partial<TType extends ConcreteTypeName<TMap>>(
+      typeConstant: TransferTypeConstant<TType> & SingleTypeName<TType>,
+      init?: Partial<Omit<Extract<TMap[TType], TransferElement>, '$type'>>
+   ): Partial<Extract<TMap[TType], TransferElement>> & TransferTypeConstant<TType>;
+}
+
+/**
+ * Bind a {@link TransferNodeBuilder} to a grammar's reflection, so a test names
+ * only the fields it cares about and a containment field the grammar gains
+ * later needs no change at the call site.
+ *
+ * Defaults come from the reflection's grammar metadata alone, so a derived
+ * field the overlay adds is never defaulted, and stays required. An array
+ * default is a fresh `[]` per node. An init field named as `undefined` keeps
+ * its default, since the init type cannot refuse `undefined` for an optional
+ * field and a plain assign would leave the node typed complete without it.
+ *
+ * The constant's `$type` is written after `init`, because the init type keeps
+ * out only a `$type` written in the call: a spread of another node passes the
+ * check and would otherwise hand back a node typed as one type and tagged as
+ * another.
+ */
+export function makeTransferNodeBuilder<TMap, TReflection extends TransferReflection = TransferReflection>(
+   reflection: TReflection
+): TransferNodeBuilder<TMap, TReflection> {
+   const build = (typeConstant: TransferTypeConstant, init: object): object => {
+      const node: Record<string, unknown> = { $type: typeConstant.$type };
+      for (const [name, property] of Object.entries(reflection.getTypeMetaData(typeConstant.$type).properties)) {
+         if (property.defaultValue !== undefined) {
+            node[name] = Array.isArray(property.defaultValue) ? [...property.defaultValue] : property.defaultValue;
+         }
+      }
+      for (const [name, value] of Object.entries(init)) {
+         if (value !== undefined || !Object.hasOwn(node, name)) {
+            node[name] = value;
+         }
+      }
+      node.$type = typeConstant.$type;
+      return node;
+   };
+   const partial = (typeConstant: TransferTypeConstant, init: object = {}): object => ({ ...init, $type: typeConstant.$type });
+   return Object.assign(build, { partial }) as TransferNodeBuilder<TMap, TReflection>;
+}