@contractspec/lib.bus 1.57.0 → 1.58.0

package/dist/index.js

@@ -1,8 +1,374 @@
-import { decodeEvent, encodeEvent, makePublisher } from "./eventBus.js";
-import { AuditableEventBus, InMemoryAuditStorage, createAuditableEventBus, makeAuditablePublisher } from "./auditableBus.js";
-import { DomainEventBus, EventRouter, createDomainBus, createEventRouter, createFilteredSubscriber, matchesFilter } from "./filtering.js";
-import { InMemoryBus } from "./inMemoryBus.js";
-import { subscribeEvent } from "./subscriber.js";
-import { MetadataContext, createMetadataContext, createMetadataFromContext, mergeMetadata } from "./metadata.js";
-
-export { AuditableEventBus, DomainEventBus, EventRouter, InMemoryAuditStorage, InMemoryBus, MetadataContext, createAuditableEventBus, createDomainBus, createEventRouter, createFilteredSubscriber, createMetadataContext, createMetadataFromContext, decodeEvent, encodeEvent, makeAuditablePublisher, makePublisher, matchesFilter, mergeMetadata, subscribeEvent };
+// @bun
+// src/eventBus.ts
+import {
+  eventKey
+} from "@contractspec/lib.contracts";
+function encodeEvent(envelope) {
+  return new TextEncoder().encode(JSON.stringify(envelope));
+}
+function decodeEvent(data) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function makePublisher(bus, spec) {
+  return async (payload, traceId) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId
+    };
+    await bus.publish(eventKey(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+// src/auditableBus.ts
+import {
+  eventKey as eventKey2
+} from "@contractspec/lib.contracts";
+class AuditableEventBus {
+  bus;
+  storage;
+  defaultMetadata;
+  shouldAudit;
+  transformAuditRecord;
+  constructor(options) {
+    this.bus = options.bus;
+    this.storage = options.storage;
+    this.defaultMetadata = options.defaultMetadata ?? {};
+    this.shouldAudit = options.shouldAudit ?? (() => true);
+    this.transformAuditRecord = options.transformAuditRecord;
+  }
+  async publish(topic, bytes) {
+    await this.bus.publish(topic, bytes);
+    if (this.storage) {
+      try {
+        const envelope = decodeEvent(bytes);
+        if (this.shouldAudit(envelope.key, envelope)) {
+          let record = {
+            id: crypto.randomUUID(),
+            eventKey: envelope.key,
+            eventVersion: envelope.version,
+            payload: envelope.payload,
+            metadata: {
+              ...this.defaultMetadata,
+              ...envelope.metadata
+            },
+            occurredAt: envelope.occurredAt,
+            traceId: envelope.traceId,
+            recordedAt: new Date
+          };
+          if (this.transformAuditRecord) {
+            record = this.transformAuditRecord(record);
+          }
+          await this.storage.store(record);
+        }
+      } catch (error) {
+        console.error("Failed to record audit:", error);
+      }
+    }
+  }
+  async subscribe(topic, handler) {
+    return this.bus.subscribe(topic, handler);
+  }
+  async queryAudit(options) {
+    if (!this.storage?.query) {
+      throw new Error("Audit storage does not support querying");
+    }
+    return this.storage.query(options);
+  }
+}
+function makeAuditablePublisher(bus, spec, defaultMetadata) {
+  return async (payload, options) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId: options?.traceId,
+      metadata: {
+        ...defaultMetadata,
+        ...options?.metadata
+      }
+    };
+    await bus.publish(eventKey2(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+class InMemoryAuditStorage {
+  records = [];
+  async store(record) {
+    this.records.push(record);
+  }
+  async query(options) {
+    let results = [...this.records];
+    if (options.eventKey) {
+      results = results.filter((r) => r.eventKey === options.eventKey);
+    }
+    if (options.actorId) {
+      results = results.filter((r) => r.metadata?.actorId === options.actorId);
+    }
+    if (options.targetId) {
+      results = results.filter((r) => r.metadata?.targetId === options.targetId);
+    }
+    if (options.orgId) {
+      results = results.filter((r) => r.metadata?.orgId === options.orgId);
+    }
+    if (options.traceId) {
+      results = results.filter((r) => r.traceId === options.traceId);
+    }
+    if (options.from) {
+      const from = options.from;
+      results = results.filter((r) => new Date(r.occurredAt) >= from);
+    }
+    if (options.to) {
+      const to = options.to;
+      results = results.filter((r) => new Date(r.occurredAt) <= to);
+    }
+    results.sort((a, b) => new Date(b.occurredAt).getTime() - new Date(a.occurredAt).getTime());
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 100;
+    return results.slice(offset, offset + limit);
+  }
+  getAll() {
+    return [...this.records];
+  }
+  clear() {
+    this.records = [];
+  }
+}
+function createAuditableEventBus(bus, options) {
+  return new AuditableEventBus({
+    bus,
+    storage: options?.storage ?? new InMemoryAuditStorage,
+    ...options
+  });
+}
+
+// src/filtering.ts
+import { satisfies } from "compare-versions";
+function matchesFilter(envelope, filter) {
+  if (filter.eventName) {
+    const pattern = filter.eventName.replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`);
+    if (!regex.test(envelope.key)) {
+      return false;
+    }
+  }
+  if (filter.domain) {
+    if (!envelope.key.startsWith(filter.domain + ".")) {
+      return false;
+    }
+  }
+  if (filter.version) {
+    if (!envelope.version || !satisfies(envelope.version, filter.version)) {
+      return false;
+    }
+  }
+  if (filter.actorId && envelope.metadata?.actorId !== filter.actorId) {
+    return false;
+  }
+  if (filter.orgId && envelope.metadata?.orgId !== filter.orgId) {
+    return false;
+  }
+  if (filter.tags) {
+    const eventTags = envelope.metadata?.tags ?? {};
+    for (const [key, value] of Object.entries(filter.tags)) {
+      if (eventTags[key] !== value) {
+        return false;
+      }
+    }
+  }
+  if (filter.predicate && !filter.predicate(envelope)) {
+    return false;
+  }
+  return true;
+}
+function createFilteredSubscriber(bus, filter, handler) {
+  return async (topic) => {
+    return bus.subscribe(topic, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, filter)) {
+        await handler(envelope);
+      }
+    });
+  };
+}
+
+class DomainEventBus {
+  bus;
+  domain;
+  constructor(bus, domain) {
+    this.bus = bus;
+    this.domain = domain;
+  }
+  async publish(spec, payload, metadata) {
+    const eventName = spec.meta.key.startsWith(this.domain + ".") ? spec.meta.key : `${this.domain}.${spec.meta.key}`;
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: eventName,
+      version: spec.meta.version,
+      payload,
+      metadata
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(envelope));
+    await this.bus.publish(`${eventName}.v${spec.meta.version}`, bytes);
+  }
+  async subscribeAll(handler) {
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      await handler(envelope);
+    });
+  }
+  async subscribeFiltered(filter, handler) {
+    const fullFilter = {
+      ...filter,
+      domain: this.domain
+    };
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, fullFilter)) {
+        await handler(envelope);
+      }
+    });
+  }
+}
+function createDomainBus(bus, domain) {
+  return new DomainEventBus(bus, domain);
+}
+
+class EventRouter {
+  routes = [];
+  route(filter, handler) {
+    this.routes.push({ filter, handler });
+    return this;
+  }
+  async dispatch(envelope) {
+    const matchingRoutes = this.routes.filter((r) => matchesFilter(envelope, r.filter));
+    await Promise.all(matchingRoutes.map((r) => r.handler(envelope)));
+  }
+  createSubscriber(bus) {
+    return async (topic) => {
+      return bus.subscribe(topic, async (bytes) => {
+        const envelope = decodeEvent(bytes);
+        await this.dispatch(envelope);
+      });
+    };
+  }
+}
+function createEventRouter() {
+  return new EventRouter;
+}
+
+// src/inMemoryBus.ts
+class InMemoryBus {
+  listeners = new Map;
+  async publish(topic, payload) {
+    const handlers = this.listeners.get(topic);
+    if (!handlers)
+      return;
+    await Promise.all([...handlers].map((h) => h(payload)));
+  }
+  async subscribe(topic, handler) {
+    const topicStr = String(topic);
+    let set = this.listeners.get(topicStr);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(topicStr, set);
+    }
+    set.add(handler);
+    return async () => {
+      set?.delete(handler);
+    };
+  }
+}
+
+// src/subscriber.ts
+async function subscribeEvent(bus, spec, handler) {
+  const topic = `${spec.meta.key}.v${spec.meta.version}`;
+  return bus.subscribe(topic, async (u8) => {
+    const env = decodeEvent(u8);
+    if (env.key !== spec.meta.key || env.version !== spec.meta.version)
+      return;
+    await handler(env.payload, { traceId: env.traceId, deliveryId: env.id });
+  });
+}
+
+// src/metadata.ts
+function createMetadataFromContext(context) {
+  return {
+    actorId: context.userId,
+    actorType: context.userId ? "user" : "system",
+    orgId: context.orgId,
+    tenantId: context.orgId,
+    sessionId: context.sessionId,
+    requestId: context.requestId,
+    traceId: context.traceId || crypto.randomUUID(),
+    clientIp: context.clientIp,
+    userAgent: context.userAgent
+  };
+}
+function mergeMetadata(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    tags: {
+      ...base.tags,
+      ...overrides.tags
+    }
+  };
+}
+
+class MetadataContext {
+  metadata;
+  constructor(initial = {}) {
+    this.metadata = { ...initial };
+    if (!this.metadata.traceId) {
+      this.metadata.traceId = crypto.randomUUID();
+    }
+  }
+  get() {
+    return { ...this.metadata };
+  }
+  set(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  tag(key, value) {
+    this.metadata.tags = { ...this.metadata.tags, [key]: value };
+    return this;
+  }
+  child(overrides = {}) {
+    return new MetadataContext(mergeMetadata(this.metadata, {
+      ...overrides,
+      spanId: crypto.randomUUID()
+    }));
+  }
+}
+function createMetadataContext(initial) {
+  return new MetadataContext(initial);
+}
+export {
+  subscribeEvent,
+  mergeMetadata,
+  matchesFilter,
+  makePublisher,
+  makeAuditablePublisher,
+  encodeEvent,
+  decodeEvent,
+  createMetadataFromContext,
+  createMetadataContext,
+  createFilteredSubscriber,
+  createEventRouter,
+  createDomainBus,
+  createAuditableEventBus,
+  MetadataContext,
+  InMemoryBus,
+  InMemoryAuditStorage,
+  EventRouter,
+  DomainEventBus,
+  AuditableEventBus
+};

package/dist/metadata.d.ts

@@ -1,82 +1,79 @@
-//#region src/metadata.d.ts
 /**
  * Event metadata that enriches events with contextual information.
  */
-interface EventMetadata {
-  /** ID of the actor (user) who triggered the event */
-  actorId?: string;
-  /** Type of actor (user, system, service) */
-  actorType?: 'user' | 'system' | 'service';
-  /** Target resource ID */
-  targetId?: string;
-  /** Target resource type */
-  targetType?: string;
-  /** Organization context */
-  orgId?: string;
-  /** Tenant context (if different from org) */
-  tenantId?: string;
-  /** Distributed trace ID */
-  traceId?: string;
-  /** Parent span ID */
-  spanId?: string;
-  /** Client IP address */
-  clientIp?: string;
-  /** Client user agent */
-  userAgent?: string;
-  /** Session ID */
-  sessionId?: string;
-  /** Request ID */
-  requestId?: string;
-  /** Source service name */
-  source?: string;
-  /** Correlation ID for related events */
-  correlationId?: string;
-  /** Custom tags for filtering/routing */
-  tags?: Record<string, string>;
+export interface EventMetadata {
+    /** ID of the actor (user) who triggered the event */
+    actorId?: string;
+    /** Type of actor (user, system, service) */
+    actorType?: 'user' | 'system' | 'service';
+    /** Target resource ID */
+    targetId?: string;
+    /** Target resource type */
+    targetType?: string;
+    /** Organization context */
+    orgId?: string;
+    /** Tenant context (if different from org) */
+    tenantId?: string;
+    /** Distributed trace ID */
+    traceId?: string;
+    /** Parent span ID */
+    spanId?: string;
+    /** Client IP address */
+    clientIp?: string;
+    /** Client user agent */
+    userAgent?: string;
+    /** Session ID */
+    sessionId?: string;
+    /** Request ID */
+    requestId?: string;
+    /** Source service name */
+    source?: string;
+    /** Correlation ID for related events */
+    correlationId?: string;
+    /** Custom tags for filtering/routing */
+    tags?: Record<string, string>;
 }
 /**
  * Create metadata from request context.
  */
-declare function createMetadataFromContext(context: {
-  userId?: string;
-  orgId?: string;
-  sessionId?: string;
-  requestId?: string;
-  traceId?: string;
-  clientIp?: string;
-  userAgent?: string;
+export declare function createMetadataFromContext(context: {
+    userId?: string;
+    orgId?: string;
+    sessionId?: string;
+    requestId?: string;
+    traceId?: string;
+    clientIp?: string;
+    userAgent?: string;
 }): EventMetadata;
 /**
  * Merge metadata with overrides.
  */
-declare function mergeMetadata(base: EventMetadata, overrides: Partial<EventMetadata>): EventMetadata;
+export declare function mergeMetadata(base: EventMetadata, overrides: Partial<EventMetadata>): EventMetadata;
 /**
  * Create a metadata context that can be passed through operations.
  */
-declare class MetadataContext {
-  private metadata;
-  constructor(initial?: EventMetadata);
-  /**
-   * Get the current metadata.
-   */
-  get(): EventMetadata;
-  /**
-   * Set a metadata value.
-   */
-  set<K extends keyof EventMetadata>(key: K, value: EventMetadata[K]): this;
-  /**
-   * Add a tag.
-   */
-  tag(key: string, value: string): this;
-  /**
-   * Create a child context with the same trace.
-   */
-  child(overrides?: Partial<EventMetadata>): MetadataContext;
+export declare class MetadataContext {
+    private metadata;
+    constructor(initial?: EventMetadata);
+    /**
+     * Get the current metadata.
+     */
+    get(): EventMetadata;
+    /**
+     * Set a metadata value.
+     */
+    set<K extends keyof EventMetadata>(key: K, value: EventMetadata[K]): this;
+    /**
+     * Add a tag.
+     */
+    tag(key: string, value: string): this;
+    /**
+     * Create a child context with the same trace.
+     */
+    child(overrides?: Partial<EventMetadata>): MetadataContext;
 }
 /**
  * Create a new metadata context.
  */
-declare function createMetadataContext(initial?: EventMetadata): MetadataContext;
-//#endregion
-export { EventMetadata, MetadataContext, createMetadataContext, createMetadataFromContext, mergeMetadata };
+export declare function createMetadataContext(initial?: EventMetadata): MetadataContext;
 //# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","names":[],"sources":["../src/metadata.ts"],"mappings":";;AAGA;;UAAiB,aAAA;EA8BF;EA5Bb,OAAA;EAEA;EAAA,SAAA;EAIA;EAFA,QAAA;EAMA;EAJA,UAAA;EAQA;EANA,KAAA;EAUA;EARA,QAAA;EAYA;EAVA,OAAA;EAcA;EAZA,MAAA;EAcO;EAZP,QAAA;EAYa;EAVb,SAAA;EAgBuC;EAdvC,SAAA;EAsBe;EApBf,SAAA;EAcA;EAZA,MAAA;EAcA;EAZA,aAAA;EAcA;EAZA,IAAA,GAAO,MAAA;AAAA;;;;iBAMO,yBAAA,CAA0B,OAAA;EACxC,MAAA;EACA,KAAA;EACA,SAAA;EACA,SAAA;EACA,OAAA;EACA,QAAA;EACA,SAAA;AAAA,IACE,aAAA;;;;iBAiBY,aAAA,CACd,IAAA,EAAM,aAAA,EACN,SAAA,EAAW,OAAA,CAAQ,aAAA,IAClB,aAAA;;;;cAcU,eAAA;EAAA,QACH,QAAA;cAEI,OAAA,GAAS,aAAA;EAHK;;;EAa1B,GAAA,CAAA,GAAO,aAAA;EAOiC;;;EAAxC,GAAA,iBAAoB,aAAA,CAAA,CAAe,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,aAAA,CAAc,CAAA;EAgB/C;;;EARjB,GAAA,CAAI,GAAA,UAAa,KAAA;EA3BT;;;EAmCR,KAAA,CAAM,SAAA,GAAW,OAAA,CAAQ,aAAA,IAAsB,eAAA;AAAA;;;;iBAajC,qBAAA,CACd,OAAA,GAAU,aAAA,GACT,eAAA"}
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC1C,yBAAyB;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qBAAqB;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,aAAa,CAYhB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CASf;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,OAAO,GAAE,aAAkB;IAOvC;;OAEG;IACH,GAAG,IAAI,aAAa;IAIpB;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAKzE;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAKrC;;OAEG;IACH,KAAK,CAAC,SAAS,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,eAAe;CAQ/D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,aAAa,GACtB,eAAe,CAEjB"}

package/dist/metadata.js

@@ -1,82 +1,61 @@
-//#region src/metadata.ts
-/**
-* Create metadata from request context.
-*/
+// @bun
+// src/metadata.ts
 function createMetadataFromContext(context) {
-	return {
-		actorId: context.userId,
-		actorType: context.userId ? "user" : "system",
-		orgId: context.orgId,
-		tenantId: context.orgId,
-		sessionId: context.sessionId,
-		requestId: context.requestId,
-		traceId: context.traceId || crypto.randomUUID(),
-		clientIp: context.clientIp,
-		userAgent: context.userAgent
-	};
+  return {
+    actorId: context.userId,
+    actorType: context.userId ? "user" : "system",
+    orgId: context.orgId,
+    tenantId: context.orgId,
+    sessionId: context.sessionId,
+    requestId: context.requestId,
+    traceId: context.traceId || crypto.randomUUID(),
+    clientIp: context.clientIp,
+    userAgent: context.userAgent
+  };
 }
-/**
-* Merge metadata with overrides.
-*/
 function mergeMetadata(base, overrides) {
-	return {
-		...base,
-		...overrides,
-		tags: {
-			...base.tags,
-			...overrides.tags
-		}
-	};
+  return {
+    ...base,
+    ...overrides,
+    tags: {
+      ...base.tags,
+      ...overrides.tags
+    }
+  };
+}
+
+class MetadataContext {
+  metadata;
+  constructor(initial = {}) {
+    this.metadata = { ...initial };
+    if (!this.metadata.traceId) {
+      this.metadata.traceId = crypto.randomUUID();
+    }
+  }
+  get() {
+    return { ...this.metadata };
+  }
+  set(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  tag(key, value) {
+    this.metadata.tags = { ...this.metadata.tags, [key]: value };
+    return this;
+  }
+  child(overrides = {}) {
+    return new MetadataContext(mergeMetadata(this.metadata, {
+      ...overrides,
+      spanId: crypto.randomUUID()
+    }));
+  }
 }
-/**
-* Create a metadata context that can be passed through operations.
-*/
-var MetadataContext = class MetadataContext {
-	metadata;
-	constructor(initial = {}) {
-		this.metadata = { ...initial };
-		if (!this.metadata.traceId) this.metadata.traceId = crypto.randomUUID();
-	}
-	/**
-	* Get the current metadata.
-	*/
-	get() {
-		return { ...this.metadata };
-	}
-	/**
-	* Set a metadata value.
-	*/
-	set(key, value) {
-		this.metadata[key] = value;
-		return this;
-	}
-	/**
-	* Add a tag.
-	*/
-	tag(key, value) {
-		this.metadata.tags = {
-			...this.metadata.tags,
-			[key]: value
-		};
-		return this;
-	}
-	/**
-	* Create a child context with the same trace.
-	*/
-	child(overrides = {}) {
-		return new MetadataContext(mergeMetadata(this.metadata, {
-			...overrides,
-			spanId: crypto.randomUUID()
-		}));
-	}
-};
-/**
-* Create a new metadata context.
-*/
 function createMetadataContext(initial) {
-	return new MetadataContext(initial);
+  return new MetadataContext(initial);
 }
-
-//#endregion
-export { MetadataContext, createMetadataContext, createMetadataFromContext, mergeMetadata };
-//# sourceMappingURL=metadata.js.map
+export {
+  mergeMetadata,
+  createMetadataFromContext,
+  createMetadataContext,
+  MetadataContext
+};