@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/chunk-7NSLGCAZ.mjs

@@ -0,0 +1,1395 @@
+import { A_FrameDynamicStructure, A_FrameDynamicStructureFeatures, A_FrameDynamicStructureOperation, A_FrameDynamicPatch } from './chunk-KTKVW3PH.mjs';
+import { A_FrameIndex } from './chunk-KNTO7FCZ.mjs';
+import { A_FrameEnv } from './chunk-RK5WSZ5J.mjs';
+import { A_FrameNamespace, A_FrameNamespaceFeatures } from './chunk-2OQMOIR5.mjs';
+import { A_FrameDefinition, A_FrameDefinitionFeatures } from './chunk-HI5SEX53.mjs';
+import { A_FrameHashHelper } from './chunk-442DXGOD.mjs';
+import { A_FrameVector } from './chunk-PABEFHCO.mjs';
+import { __decorateClass, __decorateParam } from './chunk-OI76LHVT.mjs';
+import { A_Inject, A_Feature, A_Caller, A_Error, A_Entity, A_Context, A_Scope, A_Fragment, A_Component } from '@adaas/a-concept';
+import * as http from 'http';
+import * as https from 'https';
+
+// src/lib/A-FrameChannel/A-FrameChannel.constants.ts
+var A_FrameFeatures = {
+  Request: "_A_FRAME_REQUEST",
+  Socket: "_A_FRAME_SOCKET",
+  Stream: "_A_FRAME_STREAM",
+  Send: "_A_FRAME_SEND"
+};
+var A_FrameChannelStreamStatuses = {
+  Open: "open",
+  Closed: "closed"
+};
+var A_FrameChannelStreamFeatures = {
+  open: "_A_FRAME_CHANNEL_STREAM_OPEN",
+  send: "_A_FRAME_CHANNEL_STREAM_SEND",
+  onEvent: "_A_FRAME_CHANNEL_STREAM_ON_EVENT",
+  onError: "_A_FRAME_CHANNEL_STREAM_ON_ERROR",
+  onComplete: "_A_FRAME_CHANNEL_STREAM_ON_COMPLETE",
+  onClose: "_A_FRAME_CHANNEL_STREAM_ON_CLOSE"
+};
+var A_FrameChannelSocketStatuses = {
+  Connecting: "connecting",
+  Open: "open",
+  Closed: "closed"
+};
+var A_FrameChannelSocketFeatures = {
+  onEvent: "_A_FRAME_CHANNEL_SOCKET_ON_EVENT",
+  onError: "_A_FRAME_CHANNEL_SOCKET_ON_ERROR",
+  onOpen: "_A_FRAME_CHANNEL_SOCKET_ON_OPEN",
+  onClose: "_A_FRAME_CHANNEL_SOCKET_ON_CLOSE"
+};
+var A_FrameChannelRequest = class extends A_Fragment {
+  constructor(method, path, body) {
+    super({ name: "a-frame-channel-request" });
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+  complete(response) {
+    this._response = response;
+  }
+  fail(error) {
+    this._error = error;
+  }
+  get response() {
+    return this._response;
+  }
+  get error() {
+    return this._error;
+  }
+};
+var A_FrameChannelError = class extends A_Error {
+};
+A_FrameChannelError.InvalidRequest = "InvalidRequest";
+A_FrameChannelError.Timeout = "Timeout";
+A_FrameChannelError.RequestFailed = "RequestFailed";
+var A_FrameChannelEvent = class extends A_Fragment {
+  constructor(name, data) {
+    super({ name: "a-frame-channel-event-" + name });
+    this._data = data;
+    this._eventName = name;
+  }
+  get name() {
+    return this._eventName;
+  }
+  get data() {
+    return this._data;
+  }
+};
+var A_FrameChannelStream = class extends A_Entity {
+  static onEvent(name) {
+    const eventName = (name || "all") + A_FrameChannelStreamFeatures.onEvent;
+    return (target, propertyKey, descriptor) => {
+      return A_Feature.Extend({
+        name: eventName,
+        scope: [target.constructor]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * The scope of the session, Will be destroyed after the session is closed.
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+    }
+    return this._scope;
+  }
+  get method() {
+    return this._method;
+  }
+  get path() {
+    return this._path;
+  }
+  get body() {
+    return this._body;
+  }
+  get status() {
+    return this._status;
+  }
+  get error() {
+    return this._error;
+  }
+  get initDate() {
+    return new Date(this._initDate);
+  }
+  complete() {
+    this._status = A_FrameChannelStreamStatuses.Closed;
+  }
+  fail(error) {
+    this._status = A_FrameChannelStreamStatuses.Closed;
+    this._error = error;
+  }
+  destroy() {
+    this.scope.destroy();
+  }
+  async open() {
+    await this.call(A_FrameChannelStreamFeatures.open);
+  }
+  async send() {
+    await this.call(A_FrameChannelStreamFeatures.send);
+  }
+  async propagate(name, data) {
+    const request = new A_FrameChannelEvent(name, data);
+    const executionScope = new A_Scope({
+      name: "A_FrameChannelStream.propagate",
+      fragments: [request]
+    }).inherit(this.scope);
+    try {
+      const callName = (name || "all") + A_FrameChannelStreamFeatures.onEvent;
+      await this.call(callName, executionScope);
+      executionScope.destroy();
+    } catch {
+      executionScope.destroy();
+    }
+  }
+  fromNew(newEntity) {
+    this.aseid = this.generateASEID();
+    this._method = newEntity.method;
+    this._path = newEntity.path;
+    this._body = newEntity.body;
+    this._initDate = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  fromJSON(serialized) {
+    this._method = serialized.method;
+    this._path = serialized.path;
+    this._body = serialized.body;
+    this._initDate = serialized.initDate;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      initDate: this._initDate,
+      status: this._status,
+      error: this._error ? this._error.toJSON() : void 0,
+      method: this._method,
+      path: this._path,
+      body: this._body
+    };
+  }
+};
+
+// src/lib/A-FrameDynamicSession/A-FrameDynamicSession.constants.ts
+var A_FrameDynamicSessionFeatures = {
+  Init: "_A_FRAME_DYNAMIC_SESSION_INIT",
+  Question: "_A_FRAME_DYNAMIC_SESSION_QUESTION",
+  Answer: "_A_FRAME_DYNAMIC_SESSION_ANSWER",
+  Destroy: "_A_FRAME_DYNAMIC_SESSION_DESTROY"
+};
+
+// src/lib/A-FrameDynamicSession/A-FrameDynamicSession.entity.ts
+var A_FrameDynamicSession = class extends A_Entity {
+  static get concept() {
+    return "a-frame";
+  }
+  /**
+   * 
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+    }
+    return this._scope;
+  }
+  get currentTurn() {
+    return this._currentTurn;
+  }
+  get initDate() {
+    return new Date(this._initDate);
+  }
+  static onQuestion() {
+    return;
+  }
+  static onAnswer() {
+    return;
+  }
+  fromNew(newEntity) {
+    this._turnsCount = newEntity.turnsCount || 5;
+    this._currentTurn = 0;
+    this._initDate = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  fromJSON(serialized) {
+    this._turnsCount = serialized.turnsCount;
+    this._currentTurn = serialized.currentTurn;
+    this._initDate = serialized.initDate;
+  }
+  async init() {
+    await this.call(A_FrameDynamicSessionFeatures.Init);
+  }
+  async destroy(scope) {
+    await this.call(A_FrameDynamicSessionFeatures.Destroy, scope);
+  }
+  async question() {
+    this._currentTurn++;
+    await this.call(A_FrameDynamicSessionFeatures.Question);
+  }
+  async answer() {
+    await this.call(A_FrameDynamicSessionFeatures.Answer);
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      turnsCount: this._turnsCount,
+      currentTurn: this._currentTurn,
+      initDate: this._initDate
+    };
+  }
+};
+var A_FrameChannelDsgStream = class extends A_FrameChannelStream {
+  constructor() {
+    super(...arguments);
+    this._resolvedComponents = [];
+  }
+  // ── Configuration ──────────────────────────────────────────────────────
+  /**
+   * Provide the callback that sends a component-search response back to the
+   * server via HTTP POST.  Must be set before the SSE stream is opened.
+   */
+  setRespondFn(fn) {
+    this._respondFn = fn;
+  }
+  // ── Result accessor ────────────────────────────────────────────────────
+  /**
+   * Contains the resolved components after `structure_complete` is received.
+   * Empty until the server pushes the final structure.
+   */
+  get resolvedComponents() {
+    return this._resolvedComponents;
+  }
+  async onSearchComponent(event) {
+    if (!this._respondFn) return;
+    const { requestId, vector } = event.data;
+    const queryVector = new A_FrameVector(vector ?? []);
+    const results = A_FrameIndex.search(queryVector, { topK: 1 });
+    const top = results[0];
+    await this._respondFn(requestId, {
+      component: top?.record?.name ?? null,
+      score: top?.score ?? 0
+    });
+  }
+  async onStructureComplete(event) {
+    const { components } = event.data;
+    this._resolvedComponents = Array.isArray(components) ? components : [];
+  }
+  async onStructureError(event) {
+    const { message } = event.data ?? {};
+    console.error("[A_FrameChannelDsgStream] Server reported structure error:", message ?? "unknown");
+  }
+};
+__decorateClass([
+  A_FrameChannelStream.onEvent("search_component"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onSearchComponent", 1);
+__decorateClass([
+  A_FrameChannelStream.onEvent("structure_complete"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureComplete", 1);
+__decorateClass([
+  A_FrameChannelStream.onEvent("structure_error"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureError", 1);
+
+// src/lib/A-FrameDynamicContent/A-FrameDynamicContent.constants.ts
+var A_FrameDynamicContentFeatures = {
+  Generate: "_A_FRAME_DYNAMIC_CONTENT_GENERATE",
+  Patch: "_A_FRAME_DYNAMIC_CONTENT_PATCH"
+};
+var A_FrameDynamicContentOperation = class extends A_Fragment {
+  constructor(params = {}) {
+    super({ name: "a-frame-dynamic-content-operation-context" });
+    this._meta = /* @__PURE__ */ new Map();
+    this._meta.set("params", params);
+  }
+  get params() {
+    return this._meta.get("params");
+  }
+  get(key) {
+    return this._meta.get(key);
+  }
+  set(key, value) {
+    this._meta.set(key, value);
+  }
+};
+var A_FrameDynamicContentError = class extends A_Error {
+};
+A_FrameDynamicContentError.GenerationFailed = "GenerationFailed";
+A_FrameDynamicContentError.PatchFailed = "PatchFailed";
+A_FrameDynamicContentError.InvalidPatch = "InvalidPatch";
+A_FrameDynamicContentError.PieceNotFound = "PieceNotFound";
+var _A_FrameDynamicContentIndex = class _A_FrameDynamicContentIndex extends A_Fragment {
+  constructor() {
+    super(...arguments);
+    /** Ordered list of segment IDs — defines the canonical reading order. */
+    this._order = [];
+    /** O(1) lookup by id. */
+    this._map = /* @__PURE__ */ new Map();
+  }
+  // ── Accessors ─────────────────────────────────────────────────────────────
+  get count() {
+    return this._order.length;
+  }
+  get size() {
+    return this._order.length;
+  }
+  // ── Basic mutation ────────────────────────────────────────────────────────
+  /** Append one or more segments to the end. */
+  add(...segments) {
+    segments.forEach((seg) => {
+      this._map.set(seg.id, seg);
+      if (!this._order.includes(seg.id)) {
+        this._order.push(seg.id);
+      }
+    });
+  }
+  /** Replace the content of an existing segment in-place (position unchanged). */
+  update(segment) {
+    this._map.set(segment.id, segment);
+    if (!this._order.includes(segment.id)) {
+      this._order.push(segment.id);
+    }
+  }
+  /** Remove a segment by id. */
+  remove(id) {
+    this._map.delete(id);
+    const idx = this._order.indexOf(id);
+    if (idx !== -1) this._order.splice(idx, 1);
+  }
+  /** Remove all segments. */
+  clear() {
+    this._map.clear();
+    this._order = [];
+  }
+  // ── Positional insertion ──────────────────────────────────────────────────
+  /** Insert `segment` immediately before the segment with `targetId`. */
+  insertBefore(targetId, segment) {
+    this._map.set(segment.id, segment);
+    const targetIdx = this._order.indexOf(targetId);
+    if (targetIdx === -1) {
+      this._order.push(segment.id);
+    } else {
+      this._order.splice(targetIdx, 0, segment.id);
+    }
+  }
+  /** Insert `segment` immediately after the segment with `targetId`. */
+  insertAfter(targetId, segment) {
+    this._map.set(segment.id, segment);
+    const targetIdx = this._order.indexOf(targetId);
+    if (targetIdx === -1) {
+      this._order.push(segment.id);
+    } else {
+      this._order.splice(targetIdx + 1, 0, segment.id);
+    }
+  }
+  /** Swap the content of `targetId` with `segment`, keeping the same position. */
+  replace(targetId, segment) {
+    const pos = this._order.indexOf(targetId);
+    if (pos === -1) return;
+    this._map.delete(targetId);
+    this._map.set(segment.id, segment);
+    this._order[pos] = segment.id;
+  }
+  // ── Position management ────────────────────────────────────────────────────
+  /** Move the segment with `id` to absolute zero-based `newPosition`. */
+  moveTo(id, newPosition) {
+    const from = this._order.indexOf(id);
+    if (from === -1) return;
+    this._order.splice(from, 1);
+    const clipped = Math.max(0, Math.min(newPosition, this._order.length));
+    this._order.splice(clipped, 0, id);
+  }
+  /** Move `id` to directly before `targetId`. */
+  moveBefore(id, targetId) {
+    const from = this._order.indexOf(id);
+    if (from === -1) return;
+    this._order.splice(from, 1);
+    const to = this._order.indexOf(targetId);
+    this._order.splice(to === -1 ? 0 : to, 0, id);
+  }
+  /** Move `id` to directly after `targetId`. */
+  moveAfter(id, targetId) {
+    const from = this._order.indexOf(id);
+    if (from === -1) return;
+    this._order.splice(from, 1);
+    const to = this._order.indexOf(targetId);
+    this._order.splice(to === -1 ? this._order.length : to + 1, 0, id);
+  }
+  // ── Patch operation dispatch ──────────────────────────────────────────────
+  /**
+   * Apply a single `A_FrameContentPatchOperation` to the index.
+   * For `add` and `replace` the caller must supply the resolved `segment`.
+   * For `remove` only the `op` is needed.
+   */
+  applyOperation(op, segment) {
+    switch (op.action) {
+      case "remove": {
+        if (op.targetId) this.remove(op.targetId);
+        break;
+      }
+      case "replace": {
+        if (op.targetId && segment) this.replace(op.targetId, segment);
+        break;
+      }
+      case "add": {
+        if (!segment) break;
+        if (!op.targetId || op.position === "append") {
+          this.add(segment);
+        } else if (op.position === "before") {
+          this.insertBefore(op.targetId, segment);
+        } else {
+          this.insertAfter(op.targetId, segment);
+        }
+        break;
+      }
+    }
+  }
+  // ── Lookup ────────────────────────────────────────────────────────────────
+  get(id) {
+    return this._map.get(id);
+  }
+  /** Returns all segments in their current canonical order. */
+  list() {
+    return this._order.map((id) => this._map.get(id)).filter((s) => s !== void 0);
+  }
+  // ── Search ────────────────────────────────────────────────────────────────
+  /**
+   * Rank all embedded segments by cosine similarity to the query vector.
+   */
+  search(vector, topK = _A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT) {
+    const queryVec = vector.normalize();
+    return this.list().filter((s) => s.isEmbed && s.vector).map((s) => ({
+      segment: s,
+      score: queryVec.dot(s.vector.normalize())
+    })).sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  /**
+   * Rank segments by how many instruction keywords appear in their content.
+   * Words shorter than 4 characters are ignored.
+   */
+  searchByKeywords(instruction, topK = _A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT) {
+    const keywords = instruction.toLowerCase().split(/\W+/).filter((w) => w.length > 3);
+    if (keywords.length === 0) return [];
+    return this.list().map((segment) => {
+      const lower = segment.content.toLowerCase();
+      const score = keywords.reduce(
+        (acc, kw) => acc + (lower.includes(kw) ? 1 : 0),
+        0
+      );
+      return { segment, score };
+    }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  /**
+   * Select at most `limit` segments most relevant to a patch instruction.
+   *
+   * Priority:
+   *   1. Vector search  — when `vector` is provided and segments carry embeddings.
+   *   2. Keyword search — fallback when embeddings are absent or vector is null.
+   *   3. Identity       — first N segments when neither search finds candidates.
+   */
+  selectForPatch(vector, instruction, limit = _A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT) {
+    const all = this.list();
+    if (all.length <= limit) return all;
+    if (vector) {
+      const hasEmbedded = all.some((s) => s.isEmbed);
+      if (hasEmbedded) {
+        const results = this.search(vector, limit);
+        if (results.length > 0) return results.map((r) => r.segment);
+      }
+    }
+    const kwResults = this.searchByKeywords(instruction, limit);
+    if (kwResults.length > 0) return kwResults.map((r) => r.segment);
+    return all.slice(0, limit);
+  }
+  // ── Similarity helpers ────────────────────────────────────────────────────
+  cosineSimilarity(a, b) {
+    if (!b) return 0;
+    const dot = a.dot(b);
+    const mag = a.magnitude() * b.magnitude();
+    return mag === 0 ? 0 : dot / mag;
+  }
+};
+/** Maximum segments forwarded to the server in a single patch request. */
+_A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT = 5;
+var A_FrameDynamicContentIndex = _A_FrameDynamicContentIndex;
+
+// src/lib/A-FrameSegment/A-FrameSegment.constants.ts
+var A_FrameSegmentFeatures = {
+  Load: "_A_FRAME_SEGMENT_LOAD",
+  Save: "_A_FRAME_SEGMENT_SAVE",
+  Embed: "_A_FRAME_SEGMENT_EMBED",
+  Destroy: "_A_FRAME_SEGMENT_DESTROY"
+};
+
+// src/lib/A-FrameSegment/A-FrameSegment.entity.ts
+var A_FrameSegment = class extends A_Entity {
+  static get concept() {
+    return "a-frame";
+  }
+  // ─── Getters ──────────────────────────────────────────────────────────────
+  get id() {
+    return this.aseid.id;
+  }
+  get content() {
+    return this._content;
+  }
+  get hash() {
+    return this._hash;
+  }
+  get vector() {
+    return this._vector;
+  }
+  get embedding() {
+    return this._vector?.values ?? null;
+  }
+  //-----------------------------------------------------------------------------------------------------
+  //--------------------------------------- Computed properties -----------------------------------------
+  //-----------------------------------------------------------------------------------------------------
+  get aFrameServerVersion() {
+    return this._aFrameServerVersion;
+  }
+  get aFrameVersion() {
+    return this._aFrameVersion;
+  }
+  get isEmbed() {
+    return this._vector !== void 0;
+  }
+  /**
+    * Saves Segment to storage. The actual implementation of saving is handled by the A_FrameSegmentFeatures.Save feature, which can be implemented by the environment to persist the definition to a database, file system, or other storage mechanism.
+    * 
+    * @param scope 
+    * @returns 
+    */
+  save(scope) {
+    return this.call(A_FrameSegmentFeatures.Save, scope);
+  }
+  /**
+   * Deletes the namespace from storage. The actual implementation of deletion is handled by the A_FrameSegmentFeatures.Destroy feature, which can be implemented by the environment to remove the namespace from the database, file system, or other storage mechanism.
+   * 
+   * @param scope 
+   * @returns 
+   */
+  destroy(scope) {
+    return this.call(A_FrameSegmentFeatures.Destroy, scope);
+  }
+  /**
+   * Loads the namespace from storage. The actual implementation of loading is handled by the A_FrameSegmentFeatures.Load feature, which can be implemented by the environment to retrieve the namespace from the database, file system, or other storage mechanism and populate the entity's properties accordingly.
+   * 
+   * @param scope 
+   * @returns 
+   */
+  async load(scope) {
+    return this.call(A_FrameSegmentFeatures.Load, scope);
+  }
+  /**
+   * Updates the definition's properties. This can be used to modify the source code, description, metadata, or namespace of the definition. After updating, you may want to call `embed()` again to refresh the embedding based on the new content.
+   * 
+   * @param updates 
+   */
+  update(updates) {
+    if (updates.content) this._content = updates.content;
+  }
+  /**
+   * Generates an embedding vector for the namespace using the A_FrameSegmentFeatures.Embed feature. This typically involves sending the namespace's content (name + description) to an embedding model and storing the resulting vector in the entity. Once embedded, the namespace can be searched using its vector representation.
+   * 
+   * @param scope 
+   * @returns 
+   */
+  embed(scope) {
+    return this.call(A_FrameSegmentFeatures.Embed, scope);
+  }
+  // ─── A_Entity lifecycle ───────────────────────────────────────────────────
+  fromNew(init) {
+    super.fromNew(init);
+    this._content = init.content;
+    const hashSource = this._content;
+    this._hash = A_FrameHashHelper.fnv1a(hashSource);
+  }
+  fromJSON(serialized) {
+    this._content = serialized.content;
+    this._hash = serialized.hash;
+    this._vector = serialized.embedding ? new A_FrameVector(serialized.embedding) : void 0;
+    this._embeddedAt = serialized.embeddedAt;
+    this._model = serialized.model;
+    this._credentialId = serialized.credentialId;
+    this._aFrameVersion = serialized.aFrameVersion;
+    this._aFrameServerVersion = serialized.aFrameServerVersion;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      hash: this._hash,
+      content: this._content,
+      embedding: this._vector?.values,
+      embeddedAt: this._embeddedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      model: this._model,
+      credentialId: this._credentialId,
+      aFrameVersion: this._aFrameVersion,
+      aFrameServerVersion: this._aFrameServerVersion
+    };
+  }
+  // ─── Embedding hydration ──────────────────────────────────────────────────
+  hydrateFromRecord(record) {
+    if (record.hash !== this._hash) {
+      throw new Error(
+        `A_FrameSegment.hydrateFromRecord: hash mismatch for "${this._content}" (expected ${this._hash}, got ${record.hash})`
+      );
+    }
+    this._vector = new A_FrameVector(record.embedding);
+    this._embeddedAt = record.embeddedAt;
+  }
+  /**
+   * Populate the embedding vector directly from a raw `Float32Array`.
+   * Use this when the vector is obtained externally (e.g. from a server
+   * response) without going through the full `embed()` feature pipeline.
+   */
+  hydrateFromEmbedding(embedding) {
+    this._vector = new A_FrameVector(embedding);
+  }
+  /**
+   * Build the text string sent to the embedding model.
+   * Uses content so the vector captures semantic intent.
+   */
+  toString() {
+    const parts = [`// content: ${this._content}`];
+    return parts.join("\n");
+  }
+};
+
+// src/lib/A-FrameDynamicContent/A-FrameDynamicContent.entity.ts
+var A_FrameDynamicContent = class extends A_Entity {
+  static get concept() {
+    return "a-frame";
+  }
+  /**
+   * 
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+    }
+    return this._scope;
+  }
+  get index() {
+    const index = this.scope.resolve(A_FrameDynamicContentIndex);
+    return index;
+  }
+  fromNew(options) {
+    super.fromNew(options);
+    const index = new A_FrameDynamicContentIndex({ name: `${this.aseid.id}` });
+    this.scope.register(index);
+    this.createdAt = Date.now();
+    this.prompt = options.prompt;
+    this.model = options.options?.model || "default-model";
+    this._patchPieceLimit = options.options?.patchPieceLimit || A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT;
+    this._history = [];
+    this._version = 0;
+  }
+  // ── Accessors ────────────────────────────────────────────────────────────
+  /** Ordered list of content pieces (output of the last generate or patch). */
+  get segments() {
+    return this.index.list();
+  }
+  /** Full content reconstructed from all segments in index order. */
+  get content() {
+    return this.index.list().map((s) => s.content).join("\n");
+  }
+  /** Alias for `content` — kept for backward compatibility. */
+  get text() {
+    return this.content;
+  }
+  /** Immutable patch history. */
+  get history() {
+    return this._history;
+  }
+  /** Current content version (increments with each patch). */
+  get version() {
+    return this._version;
+  }
+  /** The AI model name to use for generation / patching. */
+  get modelName() {
+    return this.model;
+  }
+  // ── Main pipeline ─────────────────────────────────────────────────────────
+  /**
+   * Generate content from the entity's prompt.
+   * Populates `pieces` and creates the first history entry.
+   */
+  async generate() {
+    const operation = new A_FrameDynamicContentOperation();
+    if (!this.scope.isInheritedFrom(A_Context.scope(this)))
+      this.scope.inherit(A_Context.scope(this));
+    const executionScope = new A_Scope({
+      name: "a-frame-dynamic-content-generate",
+      fragments: [operation]
+    }).inherit(this.scope);
+    try {
+      await this.call(A_FrameDynamicContentFeatures.Generate, executionScope);
+      executionScope.destroy();
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameDynamicContentError({
+        title: A_FrameDynamicContentError.GenerationFailed,
+        description: `Failed to generate content: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  /**
+   * Apply a natural-language patch instruction to the current pieces.
+   * The server identifies which pieces to add, replace, or remove using
+   * semantic search over piece embeddings.
+   */
+  async patch(instruction) {
+    if (!this.scope.isInheritedFrom(A_Context.scope(this)))
+      this.scope.inherit(A_Context.scope(this));
+    const executionScope = new A_Scope({
+      name: "a-frame-dynamic-content-patch"
+    }).inherit(this.scope);
+    const inputSegment = new A_FrameSegment({
+      content: instruction
+    });
+    executionScope.register(inputSegment);
+    await inputSegment.embed();
+    const targetSegments = this.index.selectForPatch(inputSegment.vector ?? null, instruction, this._patchPieceLimit);
+    const operation = new A_FrameDynamicContentOperation({
+      instruction,
+      segments: targetSegments
+    });
+    executionScope.register(operation);
+    try {
+      await this.call(A_FrameDynamicContentFeatures.Patch, executionScope);
+      executionScope.destroy();
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameDynamicContentError({
+        title: A_FrameDynamicContentError.PatchFailed,
+        description: `Failed to patch content: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  // ── Hydration ─────────────────────────────────────────────────────────────
+  /**
+   * Populate index from the segments created by the channel after a generate response.
+   * Creates the first history entry.
+   */
+  hydrateFromGeneration(segments, meta) {
+    segments.forEach((s) => this.index.add(s));
+    this._history.push(new A_FrameDynamicPatch({
+      version: this._version,
+      timestamp: Date.now(),
+      reason: `Generated for: "${this.prompt}"`,
+      encoded: Buffer.from(JSON.stringify(this.index.list())).toString("base64"),
+      delta: this.index.size
+    }));
+  }
+  /**
+   * Apply a patch diff returned by the server to the current piece list.
+   * Increments the version and records a history entry.
+   */
+  hydrateFromPatch(patchResult, meta) {
+    const prevCount = this.index.size;
+    for (const op of patchResult.operations) {
+      let segment;
+      if (op.segment) {
+        segment = new A_FrameSegment({ content: op.segment.content });
+        if (op.segment.embedding?.length) {
+          segment.hydrateFromEmbedding(new Float32Array(op.segment.embedding));
+        }
+      }
+      this.index.applyOperation(op, segment);
+    }
+    this._version++;
+    this._history.push(new A_FrameDynamicPatch({
+      version: this._version,
+      timestamp: Date.now(),
+      reason: patchResult.patchSummary,
+      encoded: Buffer.from(JSON.stringify(this.index.list())).toString("base64"),
+      delta: this.index.size - prevCount
+    }));
+  }
+  // ── Serialisation ──────────────────────────────────────────────────────────
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      prompt: this.prompt,
+      metadata: {
+        model: this.model,
+        createdAt: this.createdAt
+      },
+      history: this._history.map((item) => item.toJSON())
+    };
+  }
+};
+
+// src/lib/A-FrameChannel/A-FrameChannel.component.ts
+var A_FrameChannel = class extends A_Component {
+  async generate(prompt) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/completions", { prompt, max_tokens: 512 });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.generate",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to generate completion: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embed(input) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/embeddings", { input });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embed",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed input: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async getCredentials() {
+    const request = new A_FrameChannelRequest("GET", "/api/v1/credentials/me");
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.getCredentials",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to get credentials: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async ping() {
+    const request = new A_FrameChannelRequest("GET", "/health");
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.ping",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch {
+      executionScope.destroy();
+      return request;
+    }
+  }
+  async embedDefinition(definition, env) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/definition/embed", {
+      definition: definition.toJSON()
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embedDefinition",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      const response = request.response;
+      if (!response.data || !response.data[0] || !response.data[0].embedding) {
+        throw new A_FrameChannelError({
+          title: A_FrameChannelError.InvalidRequest,
+          description: `Invalid embedding response for definition "${definition.name}"`
+        });
+      }
+      const vector = new Float32Array(response.data[0].embedding);
+      definition.hydrateFromEmbedding(vector, {
+        model: response.model,
+        dimensions: response.meta.dimensions,
+        inputCount: response.meta.input_count,
+        aFrameServerVersion: response.meta.server_version,
+        aFrameVersion: env.A_FRAME_VERSION,
+        credentialId: response.meta.credential_id,
+        date: response.date,
+        aFrameMeta: response.aFrameMeta
+      });
+    } catch (err) {
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed definition "${definition.name}": ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embedNamespace(namespace, env) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/namespace/embed", {
+      namespace: namespace.toJSON()
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embedNamespace",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      const response = request.response;
+      if (!response.data || !response.data[0] || !response.data[0].embedding) {
+        throw new A_FrameChannelError({
+          title: A_FrameChannelError.InvalidRequest,
+          description: `Invalid embedding response for namespace "${namespace.name}"`
+        });
+      }
+      const vector = new Float32Array(response.data[0].embedding);
+      namespace.hydrateFromEmbedding(vector, {
+        model: response.model,
+        dimensions: response.meta.dimensions,
+        inputCount: response.meta.input_count,
+        aFrameServerVersion: response.meta.server_version,
+        aFrameVersion: env.A_FRAME_VERSION,
+        credentialId: response.meta.credential_id,
+        date: response.date
+      });
+    } catch (err) {
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed namespace "${namespace.name}": ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embedSegment(segment, env) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/segment/embed", {
+      segment: segment.toJSON()
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embedNamespace",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      const response = request.response;
+      if (!response.data || !response.data[0] || !response.data[0].embedding) {
+        throw new A_FrameChannelError({
+          title: A_FrameChannelError.InvalidRequest,
+          description: `Error during embed a segment: ${segment.content}`
+        });
+      }
+      const vector = new Float32Array(response.data[0].embedding);
+      segment.fromJSON({
+        aseid: segment.aseid.toString(),
+        content: segment.content,
+        hash: segment.hash,
+        embedding: vector,
+        model: response.model,
+        // dimensions: response.meta.dimensions,
+        // inputCount: response.meta.input_count,
+        aFrameServerVersion: response.meta.server_version,
+        aFrameVersion: env.A_FRAME_VERSION,
+        credentialId: response.meta.credential_id,
+        embeddedAt: response.date
+      });
+    } catch (err) {
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed segment with content "${segment.content}": ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async generateDynamicStructure(structure, session, operation) {
+    const openRequest = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/dsg/stream/open"
+    );
+    const openScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:open",
+      fragments: [openRequest]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, openScope);
+    openScope.destroy();
+    const { channelId } = openRequest.response;
+    const channel = this;
+    const dsgStream = new A_FrameChannelDsgStream({
+      method: "GET",
+      path: `/api/v1/dsg/stream/${channelId}`
+    });
+    dsgStream.setRespondFn(async (requestId, data) => {
+      const respondRequest = new A_FrameChannelRequest(
+        "POST",
+        "/api/v1/dsg/stream/respond",
+        { requestId, data }
+      );
+      const respondScope = new A_Scope({
+        name: "A_FrameChannel.generateDynamicStructure:respond",
+        fragments: [respondRequest]
+      }).inherit(A_Context.scope(channel));
+      await channel.call(A_FrameFeatures.Request, respondScope);
+      respondScope.destroy();
+    });
+    const streamScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:stream",
+      entities: [dsgStream]
+    }).inherit(A_Context.scope(this));
+    const streamTask = this.call(A_FrameFeatures.Stream, streamScope);
+    const generateRequest = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/dsg/structure/generate-stream",
+      { channelId, prompt: structure.prompt }
+    );
+    const generateScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:generate",
+      fragments: [generateRequest]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, generateScope);
+    generateScope.destroy();
+    await streamTask;
+    streamScope.destroy();
+    structure.hydrateFromResolved(
+      dsgStream.resolvedComponents,
+      { model: "sse-stream", serverVersion: "0.0.0" }
+    );
+  }
+  async generateDynamicContent(content, operation) {
+    const request = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/content/generate",
+      { prompt: content.prompt, model: content.modelName }
+    );
+    const requestScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicContent",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, requestScope);
+    requestScope.destroy();
+    const resp = request.response;
+    const segments = (resp.segments ?? []).map((w) => {
+      const seg = new A_FrameSegment({ content: w.content });
+      if (w.embedding?.length) {
+        seg.hydrateFromEmbedding(new Float32Array(w.embedding));
+      }
+      return seg;
+    });
+    content.hydrateFromGeneration(segments, {
+      model: resp.model,
+      serverVersion: resp.meta?.server_version ?? "0.0.0"
+    });
+  }
+  async patchDynamicContent(content, operation) {
+    const { instruction, segments } = operation.params;
+    const wireIdToAseid = /* @__PURE__ */ new Map();
+    const wireSegments = segments.map((s, idx) => {
+      const wireId = `s${idx}`;
+      wireIdToAseid.set(wireId, String(s.id));
+      return {
+        id: wireId,
+        index: idx,
+        text: s.content,
+        vector: s.vector ? Array.from(s.vector.values) : void 0
+      };
+    });
+    const request = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/content/patch",
+      {
+        prompt: content.prompt,
+        segments: wireSegments,
+        instruction,
+        model: content.modelName
+      }
+    );
+    const requestScope = new A_Scope({
+      name: "A_FrameChannel.patchDynamicContent",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, requestScope);
+    requestScope.destroy();
+    const resp = request.response;
+    const translatedOperations = resp.operations.map((op) => ({
+      ...op,
+      targetId: op.targetId ? wireIdToAseid.get(op.targetId) ?? op.targetId : op.targetId
+    }));
+    content.hydrateFromPatch(
+      { ...resp, operations: translatedOperations },
+      {
+        model: resp.model,
+        serverVersion: resp.meta?.server_version ?? "0.0.0"
+      }
+    );
+  }
+};
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDefinitionFeatures.Embed,
+    scope: [A_FrameDefinition]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedDefinition", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameNamespaceFeatures.Embed,
+    scope: [A_FrameNamespace]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedNamespace", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameSegmentFeatures.Embed,
+    scope: [A_FrameSegment]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedSegment", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicStructureFeatures.Generate,
+    scope: [A_FrameDynamicStructure]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicSession)),
+  __decorateParam(2, A_Inject(A_FrameDynamicStructureOperation))
+], A_FrameChannel.prototype, "generateDynamicStructure", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicContentFeatures.Generate,
+    scope: [A_FrameDynamicContent]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "generateDynamicContent", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicContentFeatures.Patch,
+    scope: [A_FrameDynamicContent]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "patchDynamicContent", 1);
+var A_FrameNodeChannel = class extends A_FrameChannel {
+  async request(context, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${context.path}`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = context.body !== void 0 ? JSON.stringify(context.body) : void 0;
+    const result = await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: context.method,
+          headers: {
+            ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {},
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`
+          }
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+          res.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if ((res.statusCode ?? 500) >= 400) {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Request to ${context.path} failed with status ${res.statusCode}`
+                })
+              );
+              return;
+            }
+            if (!raw) {
+              console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (empty)`);
+              resolve(void 0);
+              return;
+            }
+            try {
+              const parsed = JSON.parse(raw);
+              console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+              resolve(parsed);
+            } catch {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (invalid JSON)`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Invalid JSON response from ${context.path}`
+                })
+              );
+            }
+          });
+        }
+      );
+      req.setTimeout(env.A_FRAME_REQUEST_TIMEOUT, () => {
+        console.error(`[A-FrameChannel] TIMEOUT ${context.method} ${url}`);
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Request to ${context.path} timed out after ${env.A_FRAME_REQUEST_TIMEOUT}ms`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      if (payload) req.write(payload);
+      req.end();
+    });
+    context.complete(result);
+  }
+  async stream(stream, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${stream.path}`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = stream.body !== void 0 ? JSON.stringify(stream.body) : void 0;
+    await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: stream.method,
+          headers: {
+            ...payload ? { "Content-Type": "application/json" } : {},
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+            ...payload ? { "Content-Length": Buffer.byteLength(payload) } : {}
+          }
+        },
+        (res) => {
+          if ((res.statusCode ?? 500) >= 400) {
+            console.error(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url}`);
+            reject(
+              new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Stream request to ${stream.path} failed with status ${res.statusCode}`
+              })
+            );
+            return;
+          }
+          let buffer = "";
+          res.on("data", async (chunk) => {
+            buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.startsWith("data: ")) continue;
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") continue;
+              try {
+                const event = JSON.parse(data);
+                await stream.propagate(event.type, event.data);
+              } catch {
+                console.error(`[A-FrameChannel] Invalid SSE payload from ${stream.path}: ${data}`);
+              }
+            }
+          });
+          res.on("end", () => {
+            console.log(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url} (stream complete)`);
+            resolve();
+          });
+          res.on("error", (err) => reject(err));
+        }
+      );
+      req.setTimeout(3e5, () => {
+        console.error(`[A-FrameChannel] TIMEOUT ${stream.method} ${url}`);
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Stream request to ${stream.path} timed out after 300 seconds`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      if (payload) req.write(payload);
+      req.end();
+    });
+    stream.complete();
+  }
+  async send(stream, event, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${stream.path}/send`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = JSON.stringify({ type: event.name, data: event.data });
+    await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+            "Content-Length": Buffer.byteLength(payload)
+          }
+        },
+        (res) => {
+          res.resume();
+          res.on("end", () => {
+            if ((res.statusCode ?? 500) >= 400) {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} POST ${url}`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Send event "${event.name}" to ${stream.path} failed with status ${res.statusCode}`
+                })
+              );
+              return;
+            }
+            console.log(`[A-FrameChannel] --> ${res.statusCode} POST ${url} (event: ${event.name})`);
+            resolve();
+          });
+        }
+      );
+      req.setTimeout(15e3, () => {
+        console.error(`[A-FrameChannel] TIMEOUT POST ${url}`);
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Send event "${event.name}" to ${stream.path} timed out after 15 seconds`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      req.write(payload);
+      req.end();
+    });
+  }
+};
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Request,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelRequest)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "request", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Stream,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelStream)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "stream", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Send,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelStream)),
+  __decorateParam(1, A_Inject(A_FrameChannelEvent)),
+  __decorateParam(2, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "send", 1);
+
+export { A_FrameChannel, A_FrameChannelError, A_FrameChannelEvent, A_FrameChannelRequest, A_FrameChannelSocketFeatures, A_FrameChannelSocketStatuses, A_FrameChannelStream, A_FrameChannelStreamFeatures, A_FrameChannelStreamStatuses, A_FrameFeatures, A_FrameNodeChannel };
+//# sourceMappingURL=chunk-7NSLGCAZ.mjs.map
+//# sourceMappingURL=chunk-7NSLGCAZ.mjs.map