@semiont/cli 0.5.0 → 0.5.2

package/dist/cli.mjs

@@ -8378,26 +8378,26 @@ var require_BehaviorSubject = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.BehaviorSubject = void 0;
     var Subject_1 = require_Subject();
-    var BehaviorSubject3 = (function(_super) {
-      __extends(BehaviorSubject4, _super);
-      function BehaviorSubject4(_value) {
+    var BehaviorSubject2 = (function(_super) {
+      __extends(BehaviorSubject3, _super);
+      function BehaviorSubject3(_value) {
         var _this = _super.call(this) || this;
         _this._value = _value;
         return _this;
       }
-      Object.defineProperty(BehaviorSubject4.prototype, "value", {
+      Object.defineProperty(BehaviorSubject3.prototype, "value", {
         get: function() {
           return this.getValue();
         },
         enumerable: false,
         configurable: true
       });
-      BehaviorSubject4.prototype._subscribe = function(subscriber) {
+      BehaviorSubject3.prototype._subscribe = function(subscriber) {
         var subscription = _super.prototype._subscribe.call(this, subscriber);
         !subscription.closed && subscriber.next(this._value);
         return subscription;
       };
-      BehaviorSubject4.prototype.getValue = function() {
+      BehaviorSubject3.prototype.getValue = function() {
         var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
         if (hasError) {
           throw thrownError;
@@ -8405,12 +8405,12 @@ var require_BehaviorSubject = __commonJS({
         this._throwIfClosed();
         return _value;
       };
-      BehaviorSubject4.prototype.next = function(value) {
+      BehaviorSubject3.prototype.next = function(value) {
         _super.prototype.next.call(this, this._value = value);
       };
-      return BehaviorSubject4;
+      return BehaviorSubject3;
     })(Subject_1.Subject);
-    exports.BehaviorSubject = BehaviorSubject3;
+    exports.BehaviorSubject = BehaviorSubject2;
   }
 });
 
@@ -10455,7 +10455,7 @@ var require_throwError = __commonJS({
     exports.throwError = void 0;
     var Observable_1 = require_Observable();
     var isFunction_1 = require_isFunction();
-    function throwError2(errorOrErrorFactory, scheduler) {
+    function throwError3(errorOrErrorFactory, scheduler) {
       var errorFactory = isFunction_1.isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
         return errorOrErrorFactory;
       };
@@ -10466,7 +10466,7 @@ var require_throwError = __commonJS({
         return scheduler.schedule(init2, 0, subscriber);
       } : init2);
     }
-    exports.throwError = throwError2;
+    exports.throwError = throwError3;
   }
 });
 
@@ -10578,7 +10578,7 @@ var require_lastValueFrom = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.lastValueFrom = void 0;
     var EmptyError_1 = require_EmptyError();
-    function lastValueFrom5(source, config) {
+    function lastValueFrom6(source, config) {
       var hasConfig = typeof config === "object";
       return new Promise(function(resolve9, reject) {
         var _hasValue = false;
@@ -10601,7 +10601,7 @@ var require_lastValueFrom = __commonJS({
         });
       });
     }
-    exports.lastValueFrom = lastValueFrom5;
+    exports.lastValueFrom = lastValueFrom6;
   }
 });
 
@@ -12463,13 +12463,13 @@ var require_catchError = __commonJS({
     var innerFrom_1 = require_innerFrom();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     var lift_1 = require_lift();
-    function catchError(selector) {
+    function catchError2(selector) {
       return lift_1.operate(function(source, subscriber) {
         var innerSub = null;
         var syncUnsub = false;
         var handledResult;
         innerSub = source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
-          handledResult = innerFrom_1.innerFrom(selector(err, catchError(selector)(source)));
+          handledResult = innerFrom_1.innerFrom(selector(err, catchError2(selector)(source)));
           if (innerSub) {
             innerSub.unsubscribe();
             innerSub = null;
@@ -12485,7 +12485,7 @@ var require_catchError = __commonJS({
         }
       });
     }
-    exports.catchError = catchError;
+    exports.catchError = catchError2;
   }
 });
 
@@ -16922,9 +16922,10 @@ var require_operators = __commonJS({
 });
 
 // ../../packages/sdk/dist/index.js
-import { annotationId, resourceId, email, googleCredential, refreshToken, EventBus, accessToken, baseUrl, isHighlight, isComment, isAssessment, isReference, isTag, decodeWithCharset, getPrimaryMediaType, userDID, searchQuery } from "@semiont/core";
-import { HttpTransport, HttpContentTransport, createActorVM, APIError } from "@semiont/api-client";
-import { APIError as APIError2, DEGRADED_THRESHOLD_MS, HttpContentTransport as HttpContentTransport2, HttpTransport as HttpTransport2, createActorVM as createActorVM2 } from "@semiont/api-client";
+import { SemiontError, annotationId, resourceId, email, googleCredential, refreshToken, EventBus, baseUrl, accessToken, searchQuery } from "@semiont/core";
+import { SemiontError as SemiontError2, accessToken as accessToken2, annotationId as annotationId2, baseUrl as baseUrl2, entityType, refreshToken as refreshToken2, resourceId as resourceId2, userId } from "@semiont/core";
+import { HttpTransport, HttpContentTransport, APIError } from "@semiont/api-client";
+import { APIError as APIError2, HttpContentTransport as HttpContentTransport2, HttpTransport as HttpTransport2 } from "@semiont/api-client";
 async function busRequest(bus, emitChannel, payload, resultChannel, failureChannel, timeoutMs = 3e4) {
   const correlationId = crypto.randomUUID();
   const fullPayload = { ...payload, correlationId };
@@ -16935,9 +16936,31 @@ async function busRequest(bus, emitChannel, payload, resultChannel, failureChann
     ),
     bus.stream(failureChannel).pipe(
       (0, import_operators.filter)((e) => e.correlationId === correlationId),
-      (0, import_operators.map)((e) => ({ ok: false, error: new BusRequestError(e.message) }))
+      (0, import_operators.map)((e) => ({
+        ok: false,
+        error: new BusRequestError(e.message ?? "Bus request rejected", "bus.rejected", {
+          channel: failureChannel,
+          correlationId,
+          payload: e
+        })
+      }))
     )
-  ).pipe((0, import_operators.take)(1), (0, import_operators.timeout)(timeoutMs));
+  ).pipe(
+    (0, import_operators.take)(1),
+    (0, import_operators.timeout)(timeoutMs),
+    (0, import_operators.catchError)((err) => {
+      if (err instanceof import_rxjs.TimeoutError) {
+        return (0, import_rxjs.throwError)(
+          () => new BusRequestError(
+            `Bus request timed out after ${timeoutMs}ms on ${resultChannel}`,
+            "bus.timeout",
+            { channel: emitChannel, resultChannel, correlationId, timeoutMs }
+          )
+        );
+      }
+      return (0, import_rxjs.throwError)(() => err);
+    })
+  );
   const resultPromise = (0, import_rxjs.firstValueFrom)(result$);
   await bus.emit(emitChannel, fullPayload);
   const result = await resultPromise;
@@ -17012,15 +17035,71 @@ function createCache(fetchFn) {
     }
   };
 }
-var import_rxjs, import_operators, BusRequestError, ENTITY_TYPES_KEY, BrowseNamespace, MarkNamespace, BindNamespace, GatherNamespace, MatchNamespace, YieldNamespace, BeckonNamespace, JobNamespace, AuthNamespace, AdminNamespace, SemiontClient, REFRESH_BEFORE_EXP_MS;
+function wrapAsStream(source) {
+  return new StreamObservable((subscriber) => {
+    const sub = source.subscribe({
+      next: (v) => subscriber.next(v),
+      error: (e) => subscriber.error(e),
+      complete: () => subscriber.complete()
+    });
+    return () => sub.unsubscribe();
+  });
+}
+var import_rxjs, import_operators, StreamObservable, CacheObservable, wrapperCache, UploadObservable, BusRequestError, ENTITY_TYPES_KEY, BrowseNamespace, MarkNamespace, BindNamespace, GatherNamespace, MatchNamespace, YieldNamespace, BeckonNamespace, FrameNamespace, JobNamespace, AuthNamespace, AdminNamespace, SemiontClient, REFRESH_BEFORE_EXP_MS;
 var init_dist = __esm({
   "../../packages/sdk/dist/index.js"() {
     "use strict";
     import_rxjs = __toESM(require_cjs(), 1);
     import_operators = __toESM(require_operators(), 1);
-    BusRequestError = class extends Error {
-      constructor(message) {
-        super(message);
+    StreamObservable = class _StreamObservable extends import_rxjs.Observable {
+      then(onfulfilled, onrejected) {
+        return (0, import_rxjs.lastValueFrom)(this).then(onfulfilled, onrejected);
+      }
+      /** Wrap an existing Observable's subscribe behavior in a StreamObservable. */
+      static from(source) {
+        return new _StreamObservable((subscriber) => source.subscribe(subscriber));
+      }
+    };
+    CacheObservable = class _CacheObservable extends import_rxjs.Observable {
+      then(onfulfilled, onrejected) {
+        return (0, import_rxjs.firstValueFrom)(this.pipe((0, import_operators.filter)((v) => v !== void 0))).then(onfulfilled, onrejected);
+      }
+      /**
+       * Wrap an existing Observable's subscribe behavior in a `CacheObservable`.
+       *
+       * Memoizes on source identity: passing the same `source` returns the same
+       * wrapper instance. The Browse cache primitive already returns a stable
+       * Observable per key (its B4 contract), so this preserves that contract
+       * through the awaitable wrapping. Without the memo, every public-method
+       * call would produce a fresh wrapper and break referential-equality
+       * guarantees that hook-style reactive consumers depend on.
+       *
+       * Backed by a `WeakMap`, so wrappers are GC'd when their source is.
+       */
+      static from(source) {
+        let wrapper = wrapperCache.get(source);
+        if (!wrapper) {
+          wrapper = new _CacheObservable((subscriber) => source.subscribe(subscriber));
+          wrapperCache.set(source, wrapper);
+        }
+        return wrapper;
+      }
+    };
+    wrapperCache = /* @__PURE__ */ new WeakMap();
+    UploadObservable = class extends import_rxjs.Observable {
+      then(onfulfilled, onrejected) {
+        return (0, import_rxjs.lastValueFrom)(this).then((v) => {
+          if (v.phase !== "finished") {
+            throw new Error(`UploadObservable resolved on a non-finished event: ${v.phase}`);
+          }
+          const result = { resourceId: v.resourceId };
+          return onfulfilled ? onfulfilled(result) : result;
+        }, onrejected);
+      }
+    };
+    BusRequestError = class extends SemiontError {
+      constructor(message, code, details) {
+        super(message, code, details);
         this.name = "BusRequestError";
       }
     };
@@ -17030,11 +17109,6 @@ var init_dist = __esm({
         this.transport = transport;
         this.bus = bus;
         this.content = content;
-        const g = globalThis;
-        g.__SEMIONT_BROWSE_INSTANCES__ = (g.__SEMIONT_BROWSE_INSTANCES__ ?? 0) + 1;
-        const browseSerial = g.__SEMIONT_BROWSE_INSTANCES__;
-        this.__serial__ = browseSerial;
-        console.debug(`[diag] BrowseNamespace #${browseSerial} constructed`);
         this.resourceCache = createCache(async (id) => {
           const result = await busRequest(
             this.transport,
@@ -17057,32 +17131,30 @@ var init_dist = __esm({
           );
           return result.resources;
         });
-        this.annotationListCache = createCache(async (resourceId2) => {
+        this.annotationListCache = createCache(async (resourceId22) => {
           return busRequest(
             this.transport,
             "browse:annotations-requested",
-            { resourceId: resourceId2 },
+            { resourceId: resourceId22 },
             "browse:annotations-result",
             "browse:annotations-failed"
           );
         });
-        this.annotationDetailCache = createCache(async (annotationId2) => {
-          const resourceId2 = this.annotationResources.get(annotationId2);
-          if (!resourceId2) {
-            throw new Error(`Cannot fetch annotation ${annotationId2}: no resourceId known`);
+        this.annotationDetailCache = createCache(async (annotationId22) => {
+          const resourceId22 = this.annotationResources.get(annotationId22);
+          if (!resourceId22) {
+            throw new Error(`Cannot fetch annotation ${annotationId22}: no resourceId known`);
           }
           const result = await busRequest(
             this.transport,
             "browse:annotation-requested",
-            { resourceId: resourceId2, annotationId: annotationId2 },
+            { resourceId: resourceId22, annotationId: annotationId22 },
             "browse:annotation-result",
             "browse:annotation-failed"
           );
           return result.annotation;
         });
         this.entityTypesCache = createCache(async () => {
-          const serial = this.__serial__;
-          console.debug(`[diag] BrowseNamespace#${serial} entityTypes fetchFn START`);
           const result = await busRequest(
             this.transport,
             "browse:entity-types-requested",
@@ -17090,24 +17162,23 @@ var init_dist = __esm({
             "browse:entity-types-result",
             "browse:entity-types-failed"
           );
-          console.debug(`[diag] BrowseNamespace#${serial} entityTypes fetchFn RESOLVE`, JSON.stringify(result.entityTypes).slice(0, 200));
           return result.entityTypes;
         });
-        this.referencedByCache = createCache(async (resourceId2) => {
+        this.referencedByCache = createCache(async (resourceId22) => {
           const result = await busRequest(
             this.transport,
             "browse:referenced-by-requested",
-            { resourceId: resourceId2 },
+            { resourceId: resourceId22 },
             "browse:referenced-by-result",
             "browse:referenced-by-failed"
           );
           return result.referencedBy;
         });
-        this.resourceEventsCache = createCache(async (resourceId2) => {
+        this.resourceEventsCache = createCache(async (resourceId22) => {
           const result = await busRequest(
             this.transport,
             "browse:events-requested",
-            { resourceId: resourceId2 },
+            { resourceId: resourceId22 },
             "browse:events-result",
             "browse:events-failed"
           );
@@ -17119,7 +17190,7 @@ var init_dist = __esm({
       //
       // Each cache encapsulates the BehaviorSubject store, in-flight guard,
       // and per-key observable memoization that was previously open-coded
-      // here. Behavioral contract: `packages/api-client/docs/CACHE-SEMANTICS.md`.
+      // here. Behavioral contract: `packages/sdk/docs/CACHE-SEMANTICS.md`.
       //
       // Public surface (`resource()`, `annotations()`, etc.) is unchanged;
       // the caches are an implementation detail of this namespace.
@@ -17151,71 +17222,66 @@ var init_dist = __esm({
        */
       annotationListObs = /* @__PURE__ */ new Map();
       // ── Live queries ────────────────────────────────────────────────────────
-      resource(resourceId2) {
-        return this.resourceCache.observe(resourceId2);
+      //
+      // These return `CacheObservable<T>`: subscribers see `T | undefined`
+      // (with `undefined` during initial load), and `await` resolves to the
+      // first non-undefined value.
+      resource(resourceId22) {
+        return CacheObservable.from(this.resourceCache.observe(resourceId22));
       }
       resources(filters) {
         const key = JSON.stringify(filters ?? {});
         this.resourceListFilters.set(key, filters ?? {});
-        return this.resourceListCache.observe(key);
+        return CacheObservable.from(this.resourceListCache.observe(key));
       }
-      annotations(resourceId2) {
-        let obs = this.annotationListObs.get(resourceId2);
+      annotations(resourceId22) {
+        let obs = this.annotationListObs.get(resourceId22);
         if (!obs) {
-          obs = this.annotationListCache.observe(resourceId2).pipe((0, import_rxjs.map)((r) => r?.annotations));
-          this.annotationListObs.set(resourceId2, obs);
+          obs = this.annotationListCache.observe(resourceId22).pipe((0, import_rxjs.map)((r) => r?.annotations));
+          this.annotationListObs.set(resourceId22, obs);
         }
-        return obs;
+        return CacheObservable.from(obs);
       }
-      annotation(resourceId2, annotationId2) {
-        this.annotationResources.set(annotationId2, resourceId2);
-        return this.annotationDetailCache.observe(annotationId2);
+      annotation(resourceId22, annotationId22) {
+        this.annotationResources.set(annotationId22, resourceId22);
+        return CacheObservable.from(this.annotationDetailCache.observe(annotationId22));
       }
       entityTypes() {
-        const serial = this.__serial__;
-        console.debug(`[diag] BrowseNamespace#${serial} entityTypes() called`);
-        const self = this;
-        if (!self.__entityTypesDiag__) {
-          self.__entityTypesDiag__ = this.entityTypesCache.observe(ENTITY_TYPES_KEY).pipe((0, import_rxjs.map)((v) => {
-            console.debug(`[diag] BrowseNamespace#${serial} entityTypes$ EMIT`, v === void 0 ? "undefined" : JSON.stringify(v).slice(0, 200));
-            return v;
-          }));
-        }
-        return self.__entityTypesDiag__;
+        return CacheObservable.from(this.entityTypesCache.observe(ENTITY_TYPES_KEY));
       }
-      referencedBy(resourceId2) {
-        return this.referencedByCache.observe(resourceId2);
+      referencedBy(resourceId22) {
+        return CacheObservable.from(this.referencedByCache.observe(resourceId22));
       }
-      events(resourceId2) {
-        return this.resourceEventsCache.observe(resourceId2);
+      events(resourceId22) {
+        return CacheObservable.from(this.resourceEventsCache.observe(resourceId22));
       }
       // ── One-shot reads ──────────────────────────────────────────────────────
-      async resourceContent(resourceId2) {
-        const result = await this.content.getBinary(resourceId2, { accept: "text/plain" });
+      async resourceContent(resourceId22) {
+        const result = await this.content.getBinary(resourceId22, { accept: "text/plain" });
         const decoder = new TextDecoder();
         return decoder.decode(result.data);
       }
-      async resourceRepresentation(resourceId2, options) {
-        return this.content.getBinary(resourceId2, options?.accept ? { accept: options.accept } : void 0);
+      async resourceRepresentation(resourceId22, options) {
+        return this.content.getBinary(resourceId22, options?.accept ? { accept: options.accept } : void 0);
       }
-      async resourceRepresentationStream(resourceId2, options) {
-        return this.content.getBinaryStream(resourceId2, options?.accept ? { accept: options.accept } : void 0);
+      async resourceRepresentationStream(resourceId22, options) {
+        return this.content.getBinaryStream(resourceId22, options?.accept ? { accept: options.accept } : void 0);
       }
-      async resourceEvents(resourceId2) {
+      async resourceEvents(resourceId22) {
         const result = await busRequest(
           this.transport,
           "browse:events-requested",
-          { resourceId: resourceId2 },
+          { resourceId: resourceId22 },
           "browse:events-result",
           "browse:events-failed"
         );
         return result.events;
       }
-      async annotationHistory(resourceId2, annotationId2) {
+      async annotationHistory(resourceId22, annotationId22) {
         return busRequest(
           this.transport,
           "browse:annotation-history-requested",
-          { resourceId: resourceId2, annotationId: annotationId2 },
+          { resourceId: resourceId22, annotationId: annotationId22 },
           "browse:annotation-history-result",
           "browse:annotation-history-failed"
         );
@@ -17239,11 +17305,11 @@ var init_dist = __esm({
         );
       }
       // ── UI signals (local bus fan-out) ────────────────────────────────────
-      click(annotationId2, motivation) {
-        this.bus.get("browse:click").next({ annotationId: annotationId2, motivation });
+      click(annotationId22, motivation) {
+        this.bus.get("browse:click").next({ annotationId: annotationId22, motivation });
       }
-      navigateReference(resourceId2) {
-        this.bus.get("browse:reference-navigate").next({ resourceId: resourceId2 });
+      navigateReference(resourceId22) {
+        this.bus.get("browse:reference-navigate").next({ resourceId: resourceId22 });
       }
       // ── Cache-mutation API (used by the bus-event subscribers below and by
       //    other namespaces that know about specific updates) ─────────────────
@@ -17251,12 +17317,12 @@ var init_dist = __esm({
       //  - `invalidate*`     — SWR refetch (B7). Keeps prior value visible.
       //  - `removeAnnotationDetail` — drops the entry (B13a: entity gone).
       //  - `updateAnnotationInPlace` — write-through (B13b: new value known).
-      invalidateAnnotationList(resourceId2) {
-        this.annotationListCache.invalidate(resourceId2);
+      invalidateAnnotationList(resourceId22) {
+        this.annotationListCache.invalidate(resourceId22);
       }
-      removeAnnotationDetail(annotationId2) {
-        this.annotationDetailCache.remove(annotationId2);
-        this.annotationResources.delete(annotationId2);
+      removeAnnotationDetail(annotationId22) {
+        this.annotationDetailCache.remove(annotationId22);
+        this.annotationResources.delete(annotationId22);
       }
       invalidateResourceDetail(id) {
         this.resourceCache.invalidate(id);
@@ -17267,21 +17333,21 @@ var init_dist = __esm({
       invalidateEntityTypes() {
         this.entityTypesCache.invalidate(ENTITY_TYPES_KEY);
       }
-      invalidateReferencedBy(resourceId2) {
-        this.referencedByCache.invalidate(resourceId2);
+      invalidateReferencedBy(resourceId22) {
+        this.referencedByCache.invalidate(resourceId22);
       }
-      invalidateResourceEvents(resourceId2) {
-        this.resourceEventsCache.invalidate(resourceId2);
+      invalidateResourceEvents(resourceId22) {
+        this.resourceEventsCache.invalidate(resourceId22);
       }
-      updateAnnotationInPlace(resourceId2, annotation) {
-        const currentList = this.annotationListCache.get(resourceId2);
+      updateAnnotationInPlace(resourceId22, annotation) {
+        const currentList = this.annotationListCache.get(resourceId22);
         if (currentList) {
           const idx = currentList.annotations.findIndex((a) => a.id === annotation.id);
           const nextAnnotations = idx >= 0 ? currentList.annotations.map((a, i) => i === idx ? annotation : a) : [...currentList.annotations, annotation];
-          this.annotationListCache.set(resourceId2, { ...currentList, annotations: nextAnnotations });
+          this.annotationListCache.set(resourceId22, { ...currentList, annotations: nextAnnotations });
         }
         const aId = annotationId(annotation.id);
-        this.annotationResources.set(aId, resourceId2);
+        this.annotationResources.set(aId, resourceId22);
         this.annotationDetailCache.set(aId, annotation);
       }
       // ── EventBus subscriptions ──────────────────────────────────────────────
@@ -17377,7 +17443,7 @@ var init_dist = __esm({
         this.on("yield:update-ok", this.onYieldResourceMutated);
         this.on("mark:archived", this.onArchiveToggled);
         this.on("mark:unarchived", this.onArchiveToggled);
-        this.on("mark:entity-type-added", () => this.invalidateEntityTypes());
+        this.on("frame:entity-type-added", () => this.invalidateEntityTypes());
       }
     };
     MarkNamespace = class {
@@ -17385,34 +17451,28 @@ var init_dist = __esm({
         this.transport = transport;
         this.bus = bus;
       }
-      async annotation(resourceId2, input) {
-        return busRequest(
+      async annotation(input) {
+        const resourceId22 = resourceId(input.target.source);
+        const result = await busRequest(
           this.transport,
           "mark:create-request",
-          { resourceId: resourceId2, request: input },
+          { resourceId: resourceId22, request: input },
           "mark:create-ok",
           "mark:create-failed"
         );
+        return { annotationId: annotationId(result.annotationId) };
       }
-      async delete(resourceId2, annotationId2) {
-        await this.transport.emit("mark:delete", { annotationId: annotationId2, resourceId: resourceId2 });
-      }
-      async entityType(type2) {
-        await this.transport.emit("mark:add-entity-type", { tag: type2 });
-      }
-      async entityTypes(types) {
-        for (const tag of types) {
-          await this.transport.emit("mark:add-entity-type", { tag });
-        }
+      async delete(resourceId22, annotationId22) {
+        await this.transport.emit("mark:delete", { annotationId: annotationId22, resourceId: resourceId22 });
       }
-      async archive(resourceId2) {
-        await this.transport.emit("mark:archive", { resourceId: resourceId2 });
+      async archive(resourceId22) {
+        await this.transport.emit("mark:archive", { resourceId: resourceId22 });
       }
-      async unarchive(resourceId2) {
-        await this.transport.emit("mark:unarchive", { resourceId: resourceId2 });
+      async unarchive(resourceId22) {
+        await this.transport.emit("mark:unarchive", { resourceId: resourceId22 });
       }
-      assist(resourceId2, motivation, options) {
-        return new import_rxjs.Observable((subscriber) => {
+      assist(resourceId22, motivation, options) {
+        return new StreamObservable((subscriber) => {
           let done = false;
           let pollTimer = null;
           let pollInterval = null;
@@ -17452,7 +17512,7 @@ var init_dist = __esm({
                       data: {
                         jobId,
                         jobType: status.jobType ?? "annotation",
-                        resourceId: resourceId2,
+                        resourceId: resourceId22,
                         result: status.result
                       }
                     });
@@ -17489,7 +17549,7 @@ var init_dist = __esm({
             cleanup();
             subscriber.error(new Error(e.error));
           });
-          this.dispatchAssist(resourceId2, motivation, options).then(({ jobId }) => {
+          this.dispatchAssist(resourceId22, motivation, options).then(({ jobId }) => {
             if (jobId && !done) {
               activeJobId = jobId;
               resetPollTimer(jobId);
@@ -17537,7 +17597,7 @@ var init_dist = __esm({
       toggleMode() {
         this.bus.get("mark:mode-toggled").next(void 0);
       }
-      async dispatchAssist(resourceId2, motivation, options) {
+      async dispatchAssist(resourceId22, motivation, options) {
         const jobTypeMap = {
           tagging: "tag-annotation",
           linking: "reference-annotation",
@@ -17559,12 +17619,13 @@ var init_dist = __esm({
         if (options.density !== void 0) params.density = options.density;
         if (options.tone !== void 0) params.tone = options.tone;
         if (options.language !== void 0) params.language = options.language;
+        if (options.sourceLanguage !== void 0) params.sourceLanguage = options.sourceLanguage;
         if (options.schemaId !== void 0) params.schemaId = options.schemaId;
         if (options.categories !== void 0) params.categories = options.categories;
         return busRequest(
           this.transport,
           "job:create",
-          { jobType, resourceId: resourceId2, params },
+          { jobType, resourceId: resourceId22, params },
           "job:created",
           "job:create-failed"
         );
@@ -17575,11 +17636,11 @@ var init_dist = __esm({
         this.transport = transport;
         this.bus = bus;
       }
-      async body(resourceId2, annotationId2, operations) {
+      async body(resourceId22, annotationId22, operations) {
         await this.transport.emit("bind:update-body", {
           correlationId: crypto.randomUUID(),
-          annotationId: annotationId2,
-          resourceId: resourceId2,
+          annotationId: annotationId22,
+          resourceId: resourceId22,
           operations
         });
       }
@@ -17592,8 +17653,8 @@ var init_dist = __esm({
         this.transport = transport;
         this.bus = bus;
       }
-      annotation(annotationId2, resourceId2, options) {
-        return new import_rxjs.Observable((subscriber) => {
+      annotation(resourceId22, annotationId22, options) {
+        return new StreamObservable((subscriber) => {
           const correlationId = crypto.randomUUID();
           const complete$ = this.bus.get("gather:complete").pipe(
             (0, import_operators.filter)((e) => e.correlationId === correlationId)
@@ -17603,7 +17664,7 @@ var init_dist = __esm({
           );
           const sub = (0, import_rxjs.merge)(
             this.bus.get("gather:annotation-progress").pipe(
-              (0, import_operators.filter)((e) => e.annotationId === annotationId2),
+              (0, import_operators.filter)((e) => e.annotationId === annotationId22),
               (0, import_operators.map)((e) => e)
             ),
             complete$.pipe((0, import_operators.map)((e) => e))
@@ -17620,8 +17681,8 @@ var init_dist = __esm({
           });
           this.transport.emit("gather:requested", {
             correlationId,
-            annotationId: annotationId2,
-            resourceId: resourceId2,
+            annotationId: annotationId22,
+            resourceId: resourceId22,
             options: { contextWindow: options?.contextWindow ?? 2e3 }
           }).catch((error) => {
             subscriber.error(error);
@@ -17645,8 +17706,8 @@ var init_dist = __esm({
       requestSearch(input) {
         this.bus.get("match:search-requested").next(input);
       }
-      search(resourceId2, referenceId, context, options) {
-        return new import_rxjs.Observable((subscriber) => {
+      search(resourceId22, referenceId, context, options) {
+        return new StreamObservable((subscriber) => {
           const correlationId = crypto.randomUUID();
           const result$ = this.bus.get("match:search-results").pipe(
             (0, import_operators.filter)((e) => e.correlationId === correlationId)
@@ -17663,7 +17724,7 @@ var init_dist = __esm({
           });
           this.transport.emit("match:search-requested", {
             correlationId,
-            resourceId: resourceId2,
+            resourceId: resourceId22,
             referenceId,
             context,
             limit: options?.limit ?? 10,
@@ -17684,25 +17745,56 @@ var init_dist = __esm({
         this.bus = bus;
         this.content = content;
       }
-      async resource(data) {
-        const result = await this.content.putBinary({
-          name: data.name,
-          file: data.file,
-          format: data.format,
-          storageUri: data.storageUri,
-          ...data.entityTypes ? { entityTypes: data.entityTypes } : {},
-          ...data.language ? { language: data.language } : {},
-          ...data.creationMethod ? { creationMethod: data.creationMethod } : {},
-          ...data.sourceAnnotationId ? { sourceAnnotationId: data.sourceAnnotationId } : {},
-          ...data.sourceResourceId ? { sourceResourceId: data.sourceResourceId } : {},
-          ...data.generationPrompt ? { generationPrompt: data.generationPrompt } : {},
-          ...data.generator ? { generator: data.generator } : {},
-          ...data.isDraft !== void 0 ? { isDraft: data.isDraft } : {}
+      resource(data) {
+        const totalBytes = typeof Buffer !== "undefined" && data.file instanceof Buffer ? data.file.length : data.file.size;
+        return new UploadObservable((subscriber) => {
+          subscriber.next({ phase: "started", totalBytes });
+          let cancelled = false;
+          const abortController = new AbortController();
+          this.content.putBinary(
+            {
+              name: data.name,
+              file: data.file,
+              format: data.format,
+              storageUri: data.storageUri,
+              ...data.entityTypes ? { entityTypes: data.entityTypes } : {},
+              ...data.language ? { language: data.language } : {},
+              ...data.creationMethod ? { creationMethod: data.creationMethod } : {},
+              ...data.sourceAnnotationId ? { sourceAnnotationId: data.sourceAnnotationId } : {},
+              ...data.sourceResourceId ? { sourceResourceId: data.sourceResourceId } : {},
+              ...data.generationPrompt ? { generationPrompt: data.generationPrompt } : {},
+              ...data.generator ? { generator: data.generator } : {},
+              ...data.isDraft !== void 0 ? { isDraft: data.isDraft } : {}
+            },
+            {
+              // Byte-progress hook. Honored by `HttpContentTransport`'s XHR
+              // path; ignored by ky-path uploads (no `onProgress` consumer)
+              // and by `LocalContentTransport` (no wire to observe).
+              onProgress: ({ bytesUploaded, totalBytes: txTotal }) => {
+                if (cancelled) return;
+                const total = txTotal > 0 ? txTotal : totalBytes;
+                subscriber.next({ phase: "progress", bytesUploaded, totalBytes: total });
+              },
+              signal: abortController.signal
+            }
+          ).then((result) => {
+            if (cancelled) return;
+            subscriber.next({
+              phase: "finished",
+              resourceId: resourceId(result.resourceId)
+            });
+            subscriber.complete();
+          }).catch((err) => {
+            if (!cancelled) subscriber.error(err);
+          });
+          return () => {
+            cancelled = true;
+            abortController.abort();
+          };
         });
-        return { resourceId: result.resourceId };
       }
-      fromAnnotation(resourceId2, annotationId2, options) {
-        return new import_rxjs.Observable((subscriber) => {
+      fromAnnotation(resourceId22, annotationId22, options) {
+        return new StreamObservable((subscriber) => {
           let done = false;
           let pollTimer = null;
           let pollInterval = null;
@@ -17742,7 +17834,7 @@ var init_dist = __esm({
                       data: {
                         jobId: jid,
                         jobType: status.jobType ?? "generation",
-                        resourceId: resourceId2,
+                        resourceId: resourceId22,
                         result: status.result
                       }
                     });
@@ -17784,12 +17876,13 @@ var init_dist = __esm({
             "job:create",
             {
               jobType: "generation",
-              resourceId: resourceId2,
+              resourceId: resourceId22,
               params: {
-                referenceId: annotationId2,
+                referenceId: annotationId22,
                 title: options.title,
                 prompt: options.prompt,
                 language: options.language,
+                sourceLanguage: options.sourceLanguage,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens,
                 storageUri: options.storageUri,
@@ -17815,11 +17908,11 @@ var init_dist = __esm({
           };
         });
       }
-      async cloneToken(resourceId2) {
+      async cloneToken(resourceId22) {
         return busRequest(
           this.transport,
           "yield:clone-token-requested",
-          { resourceId: resourceId2 },
+          { resourceId: resourceId22 },
           "yield:clone-token-generated",
           "yield:clone-token-failed"
         );
@@ -17835,13 +17928,14 @@ var init_dist = __esm({
         return result.sourceResource;
       }
       async createFromToken(options) {
-        return busRequest(
+        const result = await busRequest(
           this.transport,
           "yield:clone-create",
           options,
           "yield:clone-created",
           "yield:clone-create-failed"
         );
+        return { resourceId: resourceId(result.resourceId) };
       }
       clone() {
         this.bus.get("yield:clone").next(void 0);
@@ -17852,14 +17946,27 @@ var init_dist = __esm({
         this.transport = transport;
         this.bus = bus;
       }
-      attention(annotationId2, resourceId2) {
-        void this.transport.emit("beckon:focus", { annotationId: annotationId2, resourceId: resourceId2 });
+      attention(resourceId22, annotationId22) {
+        void this.transport.emit("beckon:focus", { annotationId: annotationId22, resourceId: resourceId22 });
       }
-      hover(annotationId2) {
-        this.bus.get("beckon:hover").next({ annotationId: annotationId2 });
+      hover(annotationId22) {
+        this.bus.get("beckon:hover").next({ annotationId: annotationId22 });
       }
-      sparkle(annotationId2) {
-        this.bus.get("beckon:sparkle").next({ annotationId: annotationId2 });
+      sparkle(annotationId22) {
+        this.bus.get("beckon:sparkle").next({ annotationId: annotationId22 });
+      }
+    };
+    FrameNamespace = class {
+      constructor(transport) {
+        this.transport = transport;
+      }
+      async addEntityType(type2) {
+        await this.transport.emit("frame:add-entity-type", { tag: type2 });
+      }
+      async addEntityTypes(types) {
+        for (const tag of types) {
+          await this.transport.emit("frame:add-entity-type", { tag });
+        }
       }
     };
     JobNamespace = class {
@@ -17898,7 +18005,7 @@ var init_dist = __esm({
       }
       async pollUntilComplete(jobId, options) {
         const interval = options?.interval ?? 1e3;
-        const timeout7 = options?.timeout ?? 6e4;
+        const timeout6 = options?.timeout ?? 6e4;
         const startTime = Date.now();
         while (true) {
           const status = await this.status(jobId);
@@ -17906,88 +18013,86 @@ var init_dist = __esm({
           if (status.status === "complete" || status.status === "failed" || status.status === "cancelled") {
             return status;
           }
-          if (Date.now() - startTime > timeout7) {
-            throw new Error(`Job polling timeout after ${timeout7}ms`);
+          if (Date.now() - startTime > timeout6) {
+            throw new Error(`Job polling timeout after ${timeout6}ms`);
           }
           await new Promise((resolve9) => setTimeout(resolve9, interval));
         }
       }
-      async cancel(_jobId, type2) {
-        await this.transport.emit("job:cancel-requested", {
-          jobType: type2 === "generation" ? "generation" : "annotation"
-        });
+      async cancelByType(jobType) {
+        await this.transport.emit("job:cancel-requested", { jobType });
       }
       cancelRequest(jobType) {
         this.bus.get("job:cancel-requested").next({ jobType });
       }
     };
     AuthNamespace = class {
-      constructor(transport) {
-        this.transport = transport;
+      constructor(backend) {
+        this.backend = backend;
       }
       async password(emailStr, passwordStr) {
-        return this.transport.authenticatePassword(email(emailStr), passwordStr);
+        return this.backend.authenticatePassword(email(emailStr), passwordStr);
       }
       async google(credential) {
-        return this.transport.authenticateGoogle(googleCredential(credential));
+        return this.backend.authenticateGoogle(googleCredential(credential));
       }
       async refresh(token) {
-        return this.transport.refreshAccessToken(refreshToken(token));
+        return this.backend.refreshAccessToken(refreshToken(token));
       }
       async logout() {
-        await this.transport.logout();
+        await this.backend.logout();
       }
       async me() {
-        return this.transport.getCurrentUser();
+        return this.backend.getCurrentUser();
       }
       async acceptTerms() {
-        await this.transport.acceptTerms();
+        await this.backend.acceptTerms();
       }
       async mcpToken() {
-        return this.transport.generateMcpToken();
+        return this.backend.generateMcpToken();
       }
-      async mediaToken(resourceId2) {
-        return this.transport.getMediaToken(resourceId2);
+      async mediaToken(resourceId22) {
+        return this.backend.getMediaToken(resourceId22);
       }
     };
     AdminNamespace = class {
-      constructor(transport) {
-        this.transport = transport;
+      constructor(backend) {
+        this.backend = backend;
       }
       async users() {
-        const result = await this.transport.listUsers();
+        const result = await this.backend.listUsers();
         return result.users;
       }
       async userStats() {
-        return this.transport.getUserStats();
+        return this.backend.getUserStats();
       }
-      async updateUser(userId, data) {
-        const result = await this.transport.updateUser(userId, data);
+      async updateUser(userId2, data) {
+        const result = await this.backend.updateUser(userId2, data);
         return result.user;
       }
       async oauthConfig() {
-        return this.transport.getOAuthConfig();
+        return this.backend.getOAuthConfig();
       }
       async healthCheck() {
-        return this.transport.healthCheck();
+        return this.backend.healthCheck();
       }
       async status() {
-        return this.transport.getStatus();
+        return this.backend.getStatus();
       }
       async backup() {
-        return this.transport.backupKnowledgeBase();
+        return this.backend.backupKnowledgeBase();
       }
-      async restore(file, onProgress) {
-        return this.transport.restoreKnowledgeBase(file, onProgress);
+      restore(file) {
+        return wrapAsStream(this.backend.restoreKnowledgeBase(file));
       }
       async exportKnowledgeBase(params) {
-        return this.transport.exportKnowledgeBase(params);
+        return this.backend.exportKnowledgeBase(params);
       }
-      async importKnowledgeBase(file, onProgress) {
-        return this.transport.importKnowledgeBase(file, onProgress);
+      importKnowledgeBase(file) {
+        return wrapAsStream(this.backend.importKnowledgeBase(file));
       }
     };
-    SemiontClient = class {
+    SemiontClient = class _SemiontClient {
       /**
        * The wire-facing transport. Owns bus actor, HTTP, auth, admin, exchange,
        * system. Exposed for advanced consumers (workers, custom job adapters)
@@ -18006,6 +18111,15 @@ var init_dist = __esm({
       bus;
       baseUrl;
       // ── Verb-oriented namespace API ──────────────────────────────────────────
+      //
+      // The first nine namespaces are bus-driven and always present. `frame`
+      // is the schema-layer flow's surface (eighth flow); the other eight are
+      // content-layer flows plus `job`. `auth` and `admin` are backend-ops
+      // namespaces — they're only constructed when the caller passes an
+      // `IBackendOperations` instance to the constructor. A `SemiontClient`
+      // over a transport-only setup (e.g. `LocalTransport`) has
+      // `auth === undefined` / `admin === undefined`.
+      frame;
       browse;
       mark;
       bind;
@@ -18028,13 +18142,20 @@ var init_dist = __esm({
        * Callers do not pass a bus in. If they need to interact with the bus
        * (e.g. for tests or to subscribe to arbitrary channels), they read it
        * back via `client.bus`.
+       *
+       * `backend` is optional. When provided, the `auth` and `admin`
+       * namespaces are constructed against it; when omitted, they're
+       * `undefined`. For HTTP setups this is conventionally the same
+       * `HttpTransport` instance that's also passed as `transport` (HTTP
+       * implements both `ITransport` and `IBackendOperations`).
        */
-      constructor(transport, content) {
+      constructor(transport, content, backend) {
         this.transport = transport;
         this.content = content;
         this.baseUrl = transport.baseUrl;
         this.bus = new EventBus();
         this.transport.bridgeInto(this.bus);
+        this.frame = new FrameNamespace(this.transport);
         this.browse = new BrowseNamespace(this.transport, this.bus, this.content);
         this.mark = new MarkNamespace(this.transport, this.bus);
         this.bind = new BindNamespace(this.transport, this.bus);
@@ -18043,20 +18164,88 @@ var init_dist = __esm({
         this.yield = new YieldNamespace(this.transport, this.bus, this.content);
         this.beckon = new BeckonNamespace(this.transport, this.bus);
         this.job = new JobNamespace(this.transport, this.bus);
-        this.auth = new AuthNamespace(this.transport);
-        this.admin = new AdminNamespace(this.transport);
+        this.auth = backend ? new AuthNamespace(backend) : void 0;
+        this.admin = backend ? new AdminNamespace(backend) : void 0;
       }
       /** Transport-level connection state. HTTP reflects SSE health; local is always 'connected'. */
       get state$() {
         return this.transport.state$;
       }
-      subscribeToResource(resourceId2) {
-        return this.transport.subscribeToResource(resourceId2);
+      subscribeToResource(resourceId22) {
+        return this.transport.subscribeToResource(resourceId22);
       }
       dispose() {
         this.transport.dispose();
         this.content.dispose();
       }
+      /**
+       * Convenience factory for the default HTTP setup. Constructs a
+       * `BehaviorSubject<AccessToken | null>` internally, plus an
+       * `HttpTransport` and `HttpContentTransport`, and returns the wired
+       * `SemiontClient`.
+       *
+       * Use this for one-shot scripts, CLI commands, or any consumer that
+       * doesn't need to drive the token from outside (no manual refresh,
+       * no cross-tab sync). For long-running scripts that need refresh,
+       * use `SemiontSession.fromHttp(...)` (with a token already on hand)
+       * or `SemiontSession.signInHttp(...)` (credentials-first) instead —
+       * either owns the same transport/client wiring plus the
+       * proactive-refresh + storage machinery.
+       *
+       * Strings are accepted for `baseUrl` and `token`; they are branded
+       * via `baseUrl()` / `accessToken()` from `@semiont/core` automatically.
+       * Pass the already-branded values if you have them.
+       *
+       * Omit `token` for unauthenticated usage (public endpoints only).
+       */
+      static fromHttp(opts) {
+        const url = typeof opts.baseUrl === "string" ? baseUrl(opts.baseUrl) : opts.baseUrl;
+        const tok = opts.token == null ? null : typeof opts.token === "string" ? accessToken(opts.token) : opts.token;
+        const token$ = new import_rxjs.BehaviorSubject(tok);
+        const transport = new HttpTransport({ baseUrl: url, token$ });
+        const content = new HttpContentTransport(transport);
+        return new _SemiontClient(transport, content, transport);
+      }
+      /**
+       * Async factory for the credentials-first script case. Builds a
+       * transient HTTP transport, calls `auth.password(email, password)`
+       * to acquire an access token, and returns the wired client with
+       * the token populated.
+       *
+       * This is the right entry point for skills, CLI scripts, and any
+       * consumer that starts with email + password rather than a JWT
+       * already on hand. For consumers that already hold a token (CLI
+       * cached-token path, env-var token, embedded auth flow), use
+       * `fromHttp({ baseUrl, token })` instead.
+       *
+       * For long-running scripts that need refresh, use
+       * `SemiontSession.signInHttp(...)` — same credentials shape, plus
+       * the session machinery for proactive refresh and persistence.
+       *
+       * Named `signInHttp` because email+password authentication is
+       * inherently an HTTP-shaped operation in the current backend; an
+       * in-process `LocalTransport` doesn't have a credentials login
+       * path. Non-HTTP transports construct the client directly from
+       * their package's transport instance.
+       *
+       * Throws if authentication fails. The transient client is disposed
+       * before the throw, so no resources leak on failure.
+       */
+      static async signInHttp(opts) {
+        const url = typeof opts.baseUrl === "string" ? baseUrl(opts.baseUrl) : opts.baseUrl;
+        const token$ = new import_rxjs.BehaviorSubject(null);
+        const transport = new HttpTransport({ baseUrl: url, token$ });
+        const content = new HttpContentTransport(transport);
+        const client = new _SemiontClient(transport, content, transport);
+        try {
+          const auth = await client.auth.password(opts.email, opts.password);
+          token$.next(accessToken(auth.token));
+          return client;
+        } catch (err) {
+          client.dispose();
+          throw err;
+        }
+      }
     };
     REFRESH_BEFORE_EXP_MS = 5 * 60 * 1e3;
   }
@@ -18067,7 +18256,7 @@ import * as fs11 from "fs";
 import * as path11 from "path";
 import { execFileSync as execFileSync8 } from "child_process";
 import { SemiontProject as SemiontProject4 } from "@semiont/core/node";
-import { baseUrl as baseUrl2 } from "@semiont/core";
+import { baseUrl as baseUrl3 } from "@semiont/core";
 import { HttpContentTransport as HttpContentTransport3, HttpTransport as HttpTransport3 } from "@semiont/api-client";
 var checkBackendService, preflightBackendCheck, backendCheckDescriptor;
 var init_backend_check = __esm({
@@ -18149,8 +18338,8 @@ var init_backend_check = __esm({
       }
       if (status === "unhealthy" || status === "unknown") {
         const localUrl = `http://localhost:${config.port}`;
-        const transport = new HttpTransport3({ baseUrl: baseUrl2(localUrl) });
-        const client = new SemiontClient(transport, new HttpContentTransport3(transport));
+        const transport = new HttpTransport3({ baseUrl: baseUrl3(localUrl) });
+        const client = new SemiontClient(transport, new HttpContentTransport3(transport), transport);
         try {
           const healthData = await client.admin.healthCheck();
           healthy = true;
@@ -21253,7 +21442,7 @@ var init_platform2 = __esm({
 
 // src/platforms/container/handlers/web-check.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import { baseUrl as baseUrl3 } from "@semiont/core";
+import { baseUrl as baseUrl4 } from "@semiont/core";
 import { HttpContentTransport as HttpContentTransport4, HttpTransport as HttpTransport4 } from "@semiont/api-client";
 var checkWebContainer, preflightWebCheck, webCheckDescriptor, webFrontendCheckDescriptor;
 var init_web_check = __esm({
@@ -21310,8 +21499,8 @@ var init_web_check = __esm({
         try {
           if (isBackend) {
             const backendConfig = config;
-            const transport = new HttpTransport4({ baseUrl: baseUrl3(backendConfig.publicURL) });
-            const client = new SemiontClient(transport, new HttpContentTransport4(transport));
+            const transport = new HttpTransport4({ baseUrl: baseUrl4(backendConfig.publicURL) });
+            const client = new SemiontClient(transport, new HttpContentTransport4(transport), transport);
             try {
               const healthData = await client.admin.healthCheck();
               health = {
@@ -23167,7 +23356,7 @@ function generateError(state, message) {
   mark.snippet = snippet(mark);
   return new exception(message, mark);
 }
-function throwError(state, message) {
+function throwError2(state, message) {
   throw generateError(state, message);
 }
 function throwWarning(state, message) {
@@ -23183,11 +23372,11 @@ function captureSegment(state, start2, end, checkJson) {
       for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
         _character = _result.charCodeAt(_position);
         if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
-          throwError(state, "expected valid JSON character");
+          throwError2(state, "expected valid JSON character");
         }
       }
     } else if (PATTERN_NON_PRINTABLE.test(_result)) {
-      throwError(state, "the stream contains non-printable characters");
+      throwError2(state, "the stream contains non-printable characters");
     }
     state.result += _result;
   }
@@ -23195,7 +23384,7 @@ function captureSegment(state, start2, end, checkJson) {
 function mergeMappings(state, destination, source, overridableKeys) {
   var sourceKeys, key, index, quantity;
   if (!common.isObject(source)) {
-    throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+    throwError2(state, "cannot merge mappings; the provided source object is unacceptable");
   }
   sourceKeys = Object.keys(source);
   for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
@@ -23212,7 +23401,7 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
     keyNode = Array.prototype.slice.call(keyNode);
     for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
       if (Array.isArray(keyNode[index])) {
-        throwError(state, "nested arrays are not supported inside keys");
+        throwError2(state, "nested arrays are not supported inside keys");
       }
       if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
         keyNode[index] = "[object Object]";
@@ -23239,7 +23428,7 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
       state.line = startLine || state.line;
       state.lineStart = startLineStart || state.lineStart;
       state.position = startPos || state.position;
-      throwError(state, "duplicated mapping key");
+      throwError2(state, "duplicated mapping key");
     }
     setProperty(_result, keyNode, valueNode);
     delete overridableKeys[keyNode];
@@ -23257,7 +23446,7 @@ function readLineBreak(state) {
       state.position++;
     }
   } else {
-    throwError(state, "a line break is expected");
+    throwError2(state, "a line break is expected");
   }
   state.line += 1;
   state.lineStart = state.position;
@@ -23405,13 +23594,13 @@ function readSingleQuotedScalar(state, nodeIndent) {
       writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
       captureStart = captureEnd = state.position;
     } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, "unexpected end of the document within a single quoted scalar");
+      throwError2(state, "unexpected end of the document within a single quoted scalar");
     } else {
       state.position++;
       captureEnd = state.position;
     }
   }
-  throwError(state, "unexpected end of the stream within a single quoted scalar");
+  throwError2(state, "unexpected end of the stream within a single quoted scalar");
 }
 function readDoubleQuotedScalar(state, nodeIndent) {
   var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
@@ -23444,13 +23633,13 @@ function readDoubleQuotedScalar(state, nodeIndent) {
           if ((tmp = fromHexCode(ch)) >= 0) {
             hexResult = (hexResult << 4) + tmp;
           } else {
-            throwError(state, "expected hexadecimal character");
+            throwError2(state, "expected hexadecimal character");
           }
         }
         state.result += charFromCodepoint(hexResult);
         state.position++;
       } else {
-        throwError(state, "unknown escape sequence");
+        throwError2(state, "unknown escape sequence");
       }
       captureStart = captureEnd = state.position;
     } else if (is_EOL(ch)) {
@@ -23458,13 +23647,13 @@ function readDoubleQuotedScalar(state, nodeIndent) {
       writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
       captureStart = captureEnd = state.position;
     } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, "unexpected end of the document within a double quoted scalar");
+      throwError2(state, "unexpected end of the document within a double quoted scalar");
     } else {
       state.position++;
       captureEnd = state.position;
     }
   }
-  throwError(state, "unexpected end of the stream within a double quoted scalar");
+  throwError2(state, "unexpected end of the stream within a double quoted scalar");
 }
 function readFlowCollection(state, nodeIndent) {
   var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch;
@@ -23495,9 +23684,9 @@ function readFlowCollection(state, nodeIndent) {
       state.result = _result;
       return true;
     } else if (!readNext) {
-      throwError(state, "missed comma between flow collection entries");
+      throwError2(state, "missed comma between flow collection entries");
     } else if (ch === 44) {
-      throwError(state, "expected the node content, but found ','");
+      throwError2(state, "expected the node content, but found ','");
     }
     keyTag = keyNode = valueNode = null;
     isPair = isExplicitPair = false;
@@ -23540,7 +23729,7 @@ function readFlowCollection(state, nodeIndent) {
       readNext = false;
     }
   }
-  throwError(state, "unexpected end of the stream within a flow collection");
+  throwError2(state, "unexpected end of the stream within a flow collection");
 }
 function readBlockScalar(state, nodeIndent) {
   var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
@@ -23560,16 +23749,16 @@ function readBlockScalar(state, nodeIndent) {
       if (CHOMPING_CLIP === chomping) {
         chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
       } else {
-        throwError(state, "repeat of a chomping mode identifier");
+        throwError2(state, "repeat of a chomping mode identifier");
       }
     } else if ((tmp = fromDecimalCode(ch)) >= 0) {
       if (tmp === 0) {
-        throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+        throwError2(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
       } else if (!detectedIndent) {
         textIndent = nodeIndent + tmp - 1;
         detectedIndent = true;
       } else {
-        throwError(state, "repeat of an indentation width identifier");
+        throwError2(state, "repeat of an indentation width identifier");
       }
     } else {
       break;
@@ -23648,7 +23837,7 @@ function readBlockSequence(state, nodeIndent) {
   while (ch !== 0) {
     if (state.firstTabInLine !== -1) {
       state.position = state.firstTabInLine;
-      throwError(state, "tab characters must not be used in indentation");
+      throwError2(state, "tab characters must not be used in indentation");
     }
     if (ch !== 45) {
       break;
@@ -23672,7 +23861,7 @@ function readBlockSequence(state, nodeIndent) {
     skipSeparationSpace(state, true, -1);
     ch = state.input.charCodeAt(state.position);
     if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
-      throwError(state, "bad indentation of a sequence entry");
+      throwError2(state, "bad indentation of a sequence entry");
     } else if (state.lineIndent < nodeIndent) {
       break;
     }
@@ -23696,7 +23885,7 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
   while (ch !== 0) {
     if (!atExplicitKey && state.firstTabInLine !== -1) {
       state.position = state.firstTabInLine;
-      throwError(state, "tab characters must not be used in indentation");
+      throwError2(state, "tab characters must not be used in indentation");
     }
     following = state.input.charCodeAt(state.position + 1);
     _line = state.line;
@@ -23713,7 +23902,7 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
         atExplicitKey = false;
         allowCompact = true;
       } else {
-        throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+        throwError2(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
       }
       state.position += 1;
       ch = following;
@@ -23732,7 +23921,7 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
         if (ch === 58) {
           ch = state.input.charCodeAt(++state.position);
           if (!is_WS_OR_EOL(ch)) {
-            throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+            throwError2(state, "a whitespace character is expected after the key-value separator within a block mapping");
           }
           if (atExplicitKey) {
             storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
@@ -23744,14 +23933,14 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
           keyTag = state.tag;
           keyNode = state.result;
         } else if (detected) {
-          throwError(state, "can not read an implicit mapping pair; a colon is missed");
+          throwError2(state, "can not read an implicit mapping pair; a colon is missed");
         } else {
           state.tag = _tag;
           state.anchor = _anchor;
           return true;
         }
       } else if (detected) {
-        throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+        throwError2(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
       } else {
         state.tag = _tag;
         state.anchor = _anchor;
@@ -23779,7 +23968,7 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
       ch = state.input.charCodeAt(state.position);
     }
     if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
-      throwError(state, "bad indentation of a mapping entry");
+      throwError2(state, "bad indentation of a mapping entry");
     } else if (state.lineIndent < nodeIndent) {
       break;
     }
@@ -23800,7 +23989,7 @@ function readTagProperty(state) {
   ch = state.input.charCodeAt(state.position);
   if (ch !== 33) return false;
   if (state.tag !== null) {
-    throwError(state, "duplication of a tag property");
+    throwError2(state, "duplication of a tag property");
   }
   ch = state.input.charCodeAt(++state.position);
   if (ch === 60) {
@@ -23822,7 +24011,7 @@ function readTagProperty(state) {
       tagName = state.input.slice(_position, state.position);
       ch = state.input.charCodeAt(++state.position);
     } else {
-      throwError(state, "unexpected end of the stream within a verbatim tag");
+      throwError2(state, "unexpected end of the stream within a verbatim tag");
     }
   } else {
     while (ch !== 0 && !is_WS_OR_EOL(ch)) {
@@ -23830,28 +24019,28 @@ function readTagProperty(state) {
         if (!isNamed) {
           tagHandle = state.input.slice(_position - 1, state.position + 1);
           if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
-            throwError(state, "named tag handle cannot contain such characters");
+            throwError2(state, "named tag handle cannot contain such characters");
           }
           isNamed = true;
           _position = state.position + 1;
         } else {
-          throwError(state, "tag suffix cannot contain exclamation marks");
+          throwError2(state, "tag suffix cannot contain exclamation marks");
         }
       }
       ch = state.input.charCodeAt(++state.position);
     }
     tagName = state.input.slice(_position, state.position);
     if (PATTERN_FLOW_INDICATORS.test(tagName)) {
-      throwError(state, "tag suffix cannot contain flow indicator characters");
+      throwError2(state, "tag suffix cannot contain flow indicator characters");
     }
   }
   if (tagName && !PATTERN_TAG_URI.test(tagName)) {
-    throwError(state, "tag name cannot contain such characters: " + tagName);
+    throwError2(state, "tag name cannot contain such characters: " + tagName);
   }
   try {
     tagName = decodeURIComponent(tagName);
   } catch (err) {
-    throwError(state, "tag name is malformed: " + tagName);
+    throwError2(state, "tag name is malformed: " + tagName);
   }
   if (isVerbatim) {
     state.tag = tagName;
@@ -23862,7 +24051,7 @@ function readTagProperty(state) {
   } else if (tagHandle === "!!") {
     state.tag = "tag:yaml.org,2002:" + tagName;
   } else {
-    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+    throwError2(state, 'undeclared tag handle "' + tagHandle + '"');
   }
   return true;
 }
@@ -23871,7 +24060,7 @@ function readAnchorProperty(state) {
   ch = state.input.charCodeAt(state.position);
   if (ch !== 38) return false;
   if (state.anchor !== null) {
-    throwError(state, "duplication of an anchor property");
+    throwError2(state, "duplication of an anchor property");
   }
   ch = state.input.charCodeAt(++state.position);
   _position = state.position;
@@ -23879,7 +24068,7 @@ function readAnchorProperty(state) {
     ch = state.input.charCodeAt(++state.position);
   }
   if (state.position === _position) {
-    throwError(state, "name of an anchor node must contain at least one character");
+    throwError2(state, "name of an anchor node must contain at least one character");
   }
   state.anchor = state.input.slice(_position, state.position);
   return true;
@@ -23894,11 +24083,11 @@ function readAlias(state) {
     ch = state.input.charCodeAt(++state.position);
   }
   if (state.position === _position) {
-    throwError(state, "name of an alias node must contain at least one character");
+    throwError2(state, "name of an alias node must contain at least one character");
   }
   alias = state.input.slice(_position, state.position);
   if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
-    throwError(state, 'unidentified alias "' + alias + '"');
+    throwError2(state, 'unidentified alias "' + alias + '"');
   }
   state.result = state.anchorMap[alias];
   skipSeparationSpace(state, true, -1);
@@ -23962,7 +24151,7 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
         } else if (readAlias(state)) {
           hasContent = true;
           if (state.tag !== null || state.anchor !== null) {
-            throwError(state, "alias node should not have any properties");
+            throwError2(state, "alias node should not have any properties");
           }
         } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
           hasContent = true;
@@ -23984,7 +24173,7 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
     }
   } else if (state.tag === "?") {
     if (state.result !== null && state.kind !== "scalar") {
-      throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+      throwError2(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
     }
     for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
       type2 = state.implicitTypes[typeIndex];
@@ -24011,13 +24200,13 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
       }
     }
     if (!type2) {
-      throwError(state, "unknown tag !<" + state.tag + ">");
+      throwError2(state, "unknown tag !<" + state.tag + ">");
     }
     if (state.result !== null && type2.kind !== state.kind) {
-      throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"');
+      throwError2(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"');
     }
     if (!type2.resolve(state.result, state.tag)) {
-      throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+      throwError2(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
     } else {
       state.result = type2.construct(state.result, state.tag);
       if (state.anchor !== null) {
@@ -24051,7 +24240,7 @@ function readDocument(state) {
     directiveName = state.input.slice(_position, state.position);
     directiveArgs = [];
     if (directiveName.length < 1) {
-      throwError(state, "directive name must not be less than one character in length");
+      throwError2(state, "directive name must not be less than one character in length");
     }
     while (ch !== 0) {
       while (is_WHITE_SPACE(ch)) {
@@ -24082,7 +24271,7 @@ function readDocument(state) {
     state.position += 3;
     skipSeparationSpace(state, true, -1);
   } else if (hasDirectives) {
-    throwError(state, "directives end mark is expected");
+    throwError2(state, "directives end mark is expected");
   }
   composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
   skipSeparationSpace(state, true, -1);
@@ -24098,7 +24287,7 @@ function readDocument(state) {
     return;
   }
   if (state.position < state.length - 1) {
-    throwError(state, "end of the stream or a document separator is expected");
+    throwError2(state, "end of the stream or a document separator is expected");
   } else {
     return;
   }
@@ -24118,7 +24307,7 @@ function loadDocuments(input, options) {
   var nullpos = input.indexOf("\0");
   if (nullpos !== -1) {
     state.position = nullpos;
-    throwError(state, "null byte is not allowed in input");
+    throwError2(state, "null byte is not allowed in input");
   }
   state.input += "\0";
   while (state.input.charCodeAt(state.position) === 32) {
@@ -24982,19 +25171,19 @@ var init_js_yaml = __esm({
       YAML: function handleYamlDirective(state, name, args) {
         var match, major, minor;
         if (state.version !== null) {
-          throwError(state, "duplication of %YAML directive");
+          throwError2(state, "duplication of %YAML directive");
         }
         if (args.length !== 1) {
-          throwError(state, "YAML directive accepts exactly one argument");
+          throwError2(state, "YAML directive accepts exactly one argument");
         }
         match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
         if (match === null) {
-          throwError(state, "ill-formed argument of the YAML directive");
+          throwError2(state, "ill-formed argument of the YAML directive");
         }
         major = parseInt(match[1], 10);
         minor = parseInt(match[2], 10);
         if (major !== 1) {
-          throwError(state, "unacceptable YAML version of the document");
+          throwError2(state, "unacceptable YAML version of the document");
         }
         state.version = args[0];
         state.checkLineBreaks = minor < 2;
@@ -25005,23 +25194,23 @@ var init_js_yaml = __esm({
       TAG: function handleTagDirective(state, name, args) {
         var handle, prefix;
         if (args.length !== 2) {
-          throwError(state, "TAG directive accepts exactly two arguments");
+          throwError2(state, "TAG directive accepts exactly two arguments");
         }
         handle = args[0];
         prefix = args[1];
         if (!PATTERN_TAG_HANDLE.test(handle)) {
-          throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+          throwError2(state, "ill-formed tag handle (first argument) of the TAG directive");
         }
         if (_hasOwnProperty$1.call(state.tagMap, handle)) {
-          throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+          throwError2(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
         }
         if (!PATTERN_TAG_URI.test(prefix)) {
-          throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+          throwError2(state, "ill-formed tag prefix (second argument) of the TAG directive");
         }
         try {
           prefix = decodeURIComponent(prefix);
         } catch (err) {
-          throwError(state, "tag prefix is malformed: " + prefix);
+          throwError2(state, "tag prefix is malformed: " + prefix);
         }
         state.tagMap[handle] = prefix;
       }
@@ -26632,13 +26821,13 @@ var init_embedding_check = __esm({
       const model = embeddingService.getModel();
       try {
         if (embeddingType === "ollama") {
-          const baseUrl4 = embeddingService.getBaseURL().replace(/\/+$/, "");
-          const res = await fetch(`${baseUrl4}/api/tags`);
+          const baseUrl5 = embeddingService.getBaseURL().replace(/\/+$/, "");
+          const res = await fetch(`${baseUrl5}/api/tags`);
           if (!res.ok) {
             return {
               success: false,
               status: "unhealthy",
-              error: `Ollama returned ${res.status} at ${baseUrl4}/api/tags`,
+              error: `Ollama returned ${res.status} at ${baseUrl5}/api/tags`,
               metadata: { serviceType: "embedding", embeddingType, model }
             };
           }
@@ -26668,9 +26857,9 @@ var init_embedding_check = __esm({
             status: "running",
             health: {
               healthy: true,
-              details: { embeddingType, model, endpoint: baseUrl4 }
+              details: { embeddingType, model, endpoint: baseUrl5 }
             },
-            metadata: { serviceType: "embedding", embeddingType, model, endpoint: baseUrl4 }
+            metadata: { serviceType: "embedding", embeddingType, model, endpoint: baseUrl5 }
           };
         }
         return {
@@ -26729,11 +26918,11 @@ var init_embedding_provision = __esm({
         };
       }
       const model = embeddingService.getModel();
-      const baseUrl4 = embeddingService.getBaseURL().replace(/\/+$/, "");
+      const baseUrl5 = embeddingService.getBaseURL().replace(/\/+$/, "");
       if (!service.quiet) {
-        printInfo(`Pulling embedding model ${model} from ${baseUrl4}...`);
+        printInfo(`Pulling embedding model ${model} from ${baseUrl5}...`);
       }
-      const res = await fetch(`${baseUrl4}/api/pull`, {
+      const res = await fetch(`${baseUrl5}/api/pull`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ name: model, stream: false })
@@ -26761,13 +26950,13 @@ var init_embedding_provision = __esm({
         success: true,
         resources: {
           platform: "external",
-          data: { endpoint: baseUrl4, provider: embeddingType }
+          data: { endpoint: baseUrl5, provider: embeddingType }
         },
         metadata: {
           serviceType: "embedding",
           embeddingType,
           model,
-          endpoint: baseUrl4
+          endpoint: baseUrl5
         }
       };
     };
@@ -27195,13 +27384,13 @@ var init_inference_provision3 = __esm({
           metadata: { serviceType: "inference", inferenceType }
         };
       }
-      const baseUrl4 = endpoint.replace(/\/+$/, "");
+      const baseUrl5 = endpoint.replace(/\/+$/, "");
       const pulledModels = [];
       for (const model of models) {
         if (!service.quiet) {
-          printInfo(`Pulling model ${model} from ${baseUrl4}...`);
+          printInfo(`Pulling model ${model} from ${baseUrl5}...`);
         }
-        const res = await fetch(`${baseUrl4}/api/pull`, {
+        const res = await fetch(`${baseUrl5}/api/pull`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ name: model, stream: false })
@@ -27231,13 +27420,13 @@ var init_inference_provision3 = __esm({
         success: true,
         resources: {
           platform: "external",
-          data: { endpoint: baseUrl4, provider: inferenceType }
+          data: { endpoint: baseUrl5, provider: inferenceType }
         },
         metadata: {
           serviceType: "inference",
           inferenceType,
           models: pulledModels,
-          endpoint: baseUrl4
+          endpoint: baseUrl5
         }
       };
     };
@@ -32828,7 +33017,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@semiont/cli",
-      version: "0.5.0",
+      version: "0.5.2",
       description: "Semiont CLI - Unified environment management tool",
       _comment: "AWS SDK dependencies (@aws-sdk/*) are only used by platforms/aws",
       type: "module",
@@ -32875,13 +33064,13 @@ var require_package = __commonJS({
         "test:watch:unit": "vitest --watch --config vitest.config.unit.ts"
       },
       dependencies: {
-        "@semiont/api-client": "0.5.0",
-        "@semiont/content": "0.5.0",
-        "@semiont/core": "0.5.0",
-        "@semiont/event-sourcing": "0.5.0",
-        "@semiont/graph": "0.5.0",
-        "@semiont/sdk": "0.5.0",
-        "@semiont/make-meaning": "0.5.0",
+        "@semiont/api-client": "0.5.2",
+        "@semiont/content": "0.5.2",
+        "@semiont/core": "0.5.2",
+        "@semiont/event-sourcing": "0.5.2",
+        "@semiont/graph": "0.5.2",
+        "@semiont/sdk": "0.5.2",
+        "@semiont/make-meaning": "0.5.2",
         arg: "^5.0.2",
         argon2: "^0.44.0",
         express: "^5.2.1",
@@ -34226,8 +34415,8 @@ async function runBackup(options) {
   const projectRoot = findProjectRoot();
   const environment = options.environment;
   const envConfig = loadEnvironmentConfig(projectRoot, environment);
-  const baseUrl4 = envConfig.services?.backend?.publicURL;
-  if (!baseUrl4) {
+  const baseUrl5 = envConfig.services?.backend?.publicURL;
+  if (!baseUrl5) {
     throw new Error("services.backend.publicURL is required in environment config");
   }
   const project = new SemiontProject11(projectRoot);
@@ -34243,7 +34432,7 @@ async function runBackup(options) {
   }
   const output = fs38.createWriteStream(outPath);
   const manifest = await exportBackup(
-    { eventStore, content: contentStore, sourceUrl: baseUrl4, logger },
+    { eventStore, content: contentStore, sourceUrl: baseUrl5, logger },
     output
   );
   if (!options.quiet) {
@@ -34585,8 +34774,8 @@ async function runExport(options) {
   const projectRoot = findProjectRoot();
   const environment = options.environment;
   const envConfig = loadEnvironmentConfig(projectRoot, environment);
-  const baseUrl4 = envConfig.services?.backend?.publicURL;
-  if (!baseUrl4) {
+  const baseUrl5 = envConfig.services?.backend?.publicURL;
+  if (!baseUrl5) {
     throw new Error("services.backend.publicURL is required in environment config");
   }
   const project = new SemiontProject13(projectRoot);
@@ -34609,7 +34798,7 @@ async function runExport(options) {
     {
       views: eventStore.viewStorage,
       content: contentStore,
-      sourceUrl: baseUrl4,
+      sourceUrl: baseUrl5,
       entityTypes,
       includeArchived: options.includeArchived,
       logger
@@ -34730,10 +34919,10 @@ async function runImport(options) {
   if (!fs42.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const userId = options.userId ?? `did:web:localhost:users:${process.env.USER ?? "cli"}`;
+  const userId2 = options.userId ?? `did:web:localhost:users:${process.env.USER ?? "cli"}`;
   if (!options.quiet) {
     printInfo(`Importing JSON-LD archive from ${filePath}`);
-    printInfo(`User identity: ${userId}`);
+    printInfo(`User identity: ${userId2}`);
   }
   const eventBus = new EventBus5();
   const eventStore = createEventStore4(project, eventBus, logger);
@@ -34742,7 +34931,7 @@ async function runImport(options) {
   await stower.initialize();
   try {
     const input = fs42.createReadStream(filePath);
-    const result = await importLinkedData(input, { eventBus, contentStore: kb.content, userId, logger });
+    const result = await importLinkedData(input, { eventBus, contentStore: kb.content, userId: userId2, logger });
     if (!options.quiet) {
       printSuccess(
         `Import complete: ${result.resourcesCreated} resources, ${result.annotationsCreated} annotations, ${result.entityTypesAdded} entity types`
@@ -35486,8 +35675,8 @@ async function runMv(options) {
         reject(new Error(e.message ?? "Move failed"));
       });
     });
-    const userId = `did:web:localhost:users:${process.env.USER ?? "cli"}`;
-    eventBus.get("yield:mv").next({ fromUri, toUri, _userId: userId, noGit: options.noGit });
+    const userId2 = `did:web:localhost:users:${process.env.USER ?? "cli"}`;
+    eventBus.get("yield:mv").next({ fromUri, toUri, _userId: userId2, noGit: options.noGit });
     await movedPromise;
     if (!options.quiet) {
       printSuccess(`Moved: ${fromUri} \u2192 ${toUri}`);
@@ -35533,7 +35722,7 @@ var mvCmd = new CommandBuilder().name("mv").description("Move (rename) a tracked
 
 // src/core/commands/yield.ts
 init_zod();
-var import_rxjs3 = __toESM(require_cjs(), 1);
+var import_rxjs2 = __toESM(require_cjs(), 1);
 init_command_definition();
 init_base_options_schema();
 init_cli_logger();
@@ -35544,14 +35733,11 @@ import { resourceId as toResourceId, annotationId as toAnnotationId } from "@sem
 
 // src/core/api-client-factory.ts
 init_dist();
-var import_rxjs2 = __toESM(require_cjs(), 1);
 import * as fs45 from "fs";
 import * as path37 from "path";
 import * as os6 from "os";
-import { HttpContentTransport as HttpContentTransport5, HttpTransport as HttpTransport5 } from "@semiont/api-client";
 import {
-  accessToken as toAccessToken,
-  baseUrl as toBaseUrl
+  accessToken as toAccessToken
 } from "@semiont/core";
 var TOKEN_CACHE_TTL_MS = 864e5;
 function authStoreDir() {
@@ -35581,8 +35767,7 @@ function isTokenValid(cache) {
   return Date.now() < cachedAt + TOKEN_CACHE_TTL_MS;
 }
 async function acquireToken(rawBusUrl, emailStr, passwordStr) {
-  const transport = new HttpTransport5({ baseUrl: toBaseUrl(rawBusUrl) });
-  const semiont = new SemiontClient(transport, new HttpContentTransport5(transport));
+  const semiont = SemiontClient.fromHttp({ baseUrl: rawBusUrl });
   const authResult = await semiont.auth.password(emailStr, passwordStr);
   const cache = {
     bus: rawBusUrl,
@@ -35602,9 +35787,7 @@ Run: semiont login --bus ${rawBusUrl}`
     );
   }
   const token = toAccessToken(cached.token);
-  const token$ = new import_rxjs2.BehaviorSubject(token);
-  const transport = new HttpTransport5({ baseUrl: toBaseUrl(rawBusUrl), token$ });
-  const semiont = new SemiontClient(transport, new HttpContentTransport5(transport));
+  const semiont = SemiontClient.fromHttp({ baseUrl: rawBusUrl, token });
   return { semiont, token };
 }
 function resolveBusUrl(busFlag) {
@@ -35647,7 +35830,14 @@ var YieldOptionsSchema = ApiOptionsSchema.extend({
   // Delegate mode optional
   title: external_exports.string().optional(),
   prompt: external_exports.string().optional(),
+  /** BCP-47 tag — language the *generated resource* is written in. */
   language: external_exports.string().optional(),
+  /**
+   * BCP-47 tag — language of the *source resource* the annotation lives on.
+   * Goes into the prompt so the LLM understands embedded source-context
+   * snippets correctly when source ≠ target language.
+   */
+  sourceLanguage: external_exports.string().optional(),
   temperature: external_exports.coerce.number().min(0).max(1).optional(),
   maxTokens: external_exports.coerce.number().int().min(100).max(4e3).optional(),
   contextWindow: external_exports.coerce.number().int().min(100).max(5e3).default(1e3)
@@ -35674,18 +35864,20 @@ async function runDelegate(semiont, options) {
   const rawAnnotationId = options.annotation;
   const rId = toResourceId(rawResourceId);
   const aId = toAnnotationId(rawAnnotationId);
-  const context = await (0, import_rxjs3.lastValueFrom)(
-    semiont.gather.annotation(aId, rId, { contextWindow: options.contextWindow })
+  const context = await (0, import_rxjs2.lastValueFrom)(
+    semiont.gather.annotation(rId, aId, { contextWindow: options.contextWindow })
   );
   if (!options.quiet) process.stderr.write(`Generating from annotation ${rawAnnotationId}...
 `);
-  const final = await (0, import_rxjs3.lastValueFrom)(
+  const ctxSourceLanguage = context?.metadata?.language;
+  const final = await (0, import_rxjs2.lastValueFrom)(
     semiont.yield.fromAnnotation(rId, aId, {
       title: options.title ?? rawAnnotationId,
       storageUri: options.storageUri,
       context,
       prompt: options.prompt,
       language: options.language,
+      sourceLanguage: options.sourceLanguage ?? ctxSourceLanguage,
       temperature: options.temperature,
       maxTokens: options.maxTokens
     })
@@ -35699,10 +35891,10 @@ async function runYield(options) {
   const { semiont } = loadCachedClient(rawBusUrl);
   const projectRoot = findProjectRoot();
   if (options.delegate) {
-    const { resourceId: resourceId2, resourceName } = await runDelegate(semiont, options);
-    const label = resourceName ?? resourceId2 ?? options.storageUri;
-    if (!options.quiet) printSuccess(`Yielded: ${options.storageUri} \u2192 ${resourceId2 ?? "(pending)"}`);
-    process.stdout.write(JSON.stringify({ resourceId: resourceId2, resourceName, storageUri: options.storageUri }));
+    const { resourceId: resourceId3, resourceName } = await runDelegate(semiont, options);
+    const label = resourceName ?? resourceId3 ?? options.storageUri;
+    if (!options.quiet) printSuccess(`Yielded: ${options.storageUri} \u2192 ${resourceId3 ?? "(pending)"}`);
+    process.stdout.write(JSON.stringify({ resourceId: resourceId3, resourceName, storageUri: options.storageUri }));
     if (!options.quiet) process.stdout.write("\n");
     return {
       command: "yield",
@@ -35711,7 +35903,7 @@ async function runYield(options) {
       duration: Date.now() - startTime,
       summary: { succeeded: 1, failed: 0, total: 1, warnings: 0 },
       executionContext: { user: process.env.USER || "unknown", workingDirectory: process.cwd(), dryRun: options.dryRun },
-      results: [{ entity: label, platform: "posix", success: true, metadata: { resourceId: resourceId2, storageUri: options.storageUri }, duration: Date.now() - startTime }]
+      results: [{ entity: label, platform: "posix", success: true, metadata: { resourceId: resourceId3, storageUri: options.storageUri }, duration: Date.now() - startTime }]
     };
   }
   let succeeded = 0;
@@ -35733,11 +35925,11 @@ async function runYield(options) {
     const storageUri = `file://${relPath}`;
     const name = options.name ?? path38.basename(filePath, path38.extname(filePath));
     const format = guessFormat(filePath);
-    const { resourceId: resourceId2 } = await semiont.yield.resource(
+    const { resourceId: resourceId3 } = await semiont.yield.resource(
       { name, file: content, format, storageUri }
     );
-    if (!options.quiet) printSuccess(`Yielded: ${filePath} \u2192 ${resourceId2}`);
-    results.push({ entity: filePath, platform: "posix", success: true, metadata: { resourceId: resourceId2, storageUri }, duration: Date.now() - fileStart });
+    if (!options.quiet) printSuccess(`Yielded: ${filePath} \u2192 ${resourceId3}`);
+    results.push({ entity: filePath, platform: "posix", success: true, metadata: { resourceId: resourceId3, storageUri }, duration: Date.now() - fileStart });
     succeeded++;
   }
   return {
@@ -35823,7 +36015,7 @@ init_command_definition();
 init_base_options_schema();
 init_cli_logger();
 import { resourceId as toResourceId2 } from "@semiont/core";
-var import_rxjs4 = __toESM(require_cjs(), 1);
+var import_rxjs3 = __toESM(require_cjs(), 1);
 var MOTIVATIONS = ["highlighting", "commenting", "tagging", "assessing", "linking"];
 var CONTEXT_WINDOW = 32;
 var MarkOptionsSchema = ApiOptionsSchema.extend({
@@ -35856,6 +36048,19 @@ var MarkOptionsSchema = ApiOptionsSchema.extend({
   instructions: external_exports.string().optional(),
   density: external_exports.coerce.number().int().optional(),
   tone: external_exports.enum(["scholarly", "explanatory", "conversational", "technical", "analytical", "critical", "balanced", "constructive"]).optional(),
+  /**
+   * BCP-47 tag for the annotation body language. Tells the LLM what language
+   * to write generated body text in (comment/assessment) and stamps the
+   * `language` field on every TextualBody the worker produces. Independent
+   * from --source-language; this one is about the *output*.
+   */
+  language: external_exports.string().optional(),
+  /**
+   * BCP-47 tag for the source-resource language. Goes into the prompt so the
+   * LLM analyzes non-English source correctly. Independent from --language;
+   * this one is about the *input*.
+   */
+  sourceLanguage: external_exports.string().optional(),
   // ── Delegate mode: linking ─────────────────────────────────────────────
   entityType: external_exports.array(external_exports.string()).default([]),
   includeDescriptive: external_exports.boolean().default(false),
@@ -35880,8 +36085,8 @@ var MarkOptionsSchema = ApiOptionsSchema.extend({
     }
   }
 });
-async function fetchResourceText(semiont, resourceId2) {
-  const { data } = await semiont.browse.resourceRepresentation(resourceId2, { accept: "text/plain" });
+async function fetchResourceText(semiont, resourceId3) {
+  const { data } = await semiont.browse.resourceRepresentation(resourceId3, { accept: "text/plain" });
   return new TextDecoder().decode(data);
 }
 function buildTextSelector(options, content) {
@@ -35919,7 +36124,7 @@ function buildTextSelector(options, content) {
   }
   return selectors;
 }
-async function buildSelector(options, semiont, resourceId2) {
+async function buildSelector(options, semiont, resourceId3) {
   const hasText = options.quote !== void 0 || options.start !== void 0 && options.end !== void 0;
   const hasSvg = options.svg !== void 0;
   const hasFragment = options.fragment !== void 0;
@@ -35936,7 +36141,7 @@ async function buildSelector(options, semiont, resourceId2) {
     return f;
   }
   if (!hasText) return void 0;
-  const content = options.fetchContent ? await fetchResourceText(semiont, resourceId2) : void 0;
+  const content = options.fetchContent ? await fetchResourceText(semiont, resourceId3) : void 0;
   const selectors = buildTextSelector(options, content);
   if (selectors.length === 0) return void 0;
   if (selectors.length === 1) return selectors[0];
@@ -35961,18 +36166,20 @@ function buildBody(options) {
 async function runDelegate2(semiont, options) {
   const rawResourceId = options.resourceIdArr[0];
   const rId = toResourceId2(rawResourceId);
-  const { motivation, instructions, density, tone, entityType, includeDescriptive, schemaId, category } = options;
+  const { motivation, instructions, density, tone, entityType: entityType2, includeDescriptive, schemaId, category, language, sourceLanguage } = options;
   if (!options.quiet) process.stderr.write(`Annotating ${motivation} on ${rawResourceId}...
 `);
-  const final = await (0, import_rxjs4.lastValueFrom)(
+  const final = await (0, import_rxjs3.lastValueFrom)(
     semiont.mark.assist(rId, motivation, {
       instructions,
       density,
       tone,
-      entityTypes: entityType,
+      entityTypes: entityType2,
       includeDescriptiveReferences: includeDescriptive,
       schemaId,
-      categories: category
+      categories: category,
+      language,
+      sourceLanguage
     })
   );
   const r = (final.kind === "complete" ? final.data.result : void 0) ?? {};
@@ -36000,8 +36207,8 @@ async function runMark(options) {
     };
   }
   const rawResourceId = options.resourceIdArr[0];
-  const resourceId2 = toResourceId2(rawResourceId);
-  const selector = await buildSelector(options, semiont, resourceId2);
+  const resourceId3 = toResourceId2(rawResourceId);
+  const selector = await buildSelector(options, semiont, resourceId3);
   const body = buildBody(options);
   const target = selector !== void 0 ? { source: rawResourceId, selector } : { source: rawResourceId, selector: void 0 };
   const request = {
@@ -36009,8 +36216,8 @@ async function runMark(options) {
     target,
     body
   };
-  const { annotationId: annotationId2 } = await semiont.mark.annotation(resourceId2, request);
-  if (!options.quiet) printSuccess(`Marked: ${rawResourceId} \u2192 ${annotationId2}`);
+  const { annotationId: annotationId3 } = await semiont.mark.annotation(request);
+  if (!options.quiet) printSuccess(`Marked: ${rawResourceId} \u2192 ${annotationId3}`);
   return {
     command: "mark",
     environment: rawBusUrl,
@@ -36018,7 +36225,7 @@ async function runMark(options) {
     duration: Date.now() - startTime,
     summary: { succeeded: 1, failed: 0, total: 1, warnings: 0 },
     executionContext: { user: process.env.USER || "unknown", workingDirectory: process.cwd(), dryRun: options.dryRun },
-    results: [{ entity: rawResourceId, platform: "posix", success: true, metadata: { annotationId: annotationId2 }, duration: Date.now() - startTime }]
+    results: [{ entity: rawResourceId, platform: "posix", success: true, metadata: { annotationId: annotationId3 }, duration: Date.now() - startTime }]
   };
 }
 var markCmd = new CommandBuilder().name("mark").description(
@@ -36149,7 +36356,7 @@ var markCmd = new CommandBuilder().name("mark").description(
 
 // src/core/commands/gather.ts
 init_zod();
-var import_rxjs5 = __toESM(require_cjs(), 1);
+var import_rxjs4 = __toESM(require_cjs(), 1);
 init_command_definition();
 init_base_options_schema();
 import { resourceId as toResourceId3, annotationId as toAnnotationId2 } from "@semiont/core";
@@ -36176,8 +36383,8 @@ async function runGather(options) {
     }
     const rid = toResourceId3(rawResourceId);
     const aid = toAnnotationId2(rawAnnotationId);
-    result = await (0, import_rxjs5.lastValueFrom)(
-      semiont.gather.annotation(aid, rid, { contextWindow: options.contextWindow })
+    result = await (0, import_rxjs4.lastValueFrom)(
+      semiont.gather.annotation(rid, aid, { contextWindow: options.contextWindow })
     );
   } else {
     throw new Error(`Unknown subcommand: ${subcommand}. Use 'resource' or 'annotation'.`);
@@ -36219,7 +36426,7 @@ var gatherCmd = new CommandBuilder().name("gather").description("Fetch LLM-optim
 
 // src/core/commands/match.ts
 init_zod();
-var import_rxjs6 = __toESM(require_cjs(), 1);
+var import_rxjs5 = __toESM(require_cjs(), 1);
 init_command_definition();
 init_base_options_schema();
 import { resourceId as toResourceId4, annotationId as toAnnotationId3 } from "@semiont/core";
@@ -36233,18 +36440,18 @@ var MatchOptionsSchema = ApiOptionsSchema.extend({
 async function runMatch(options) {
   const startTime = Date.now();
   const [rawResourceId, rawAnnotationId] = options.args;
-  const resourceId2 = toResourceId4(rawResourceId);
-  const annotationId2 = toAnnotationId3(rawAnnotationId);
+  const resourceId3 = toResourceId4(rawResourceId);
+  const annotationId3 = toAnnotationId3(rawAnnotationId);
   const rawBusUrl = resolveBusUrl(options.bus);
   const { semiont } = loadCachedClient(rawBusUrl);
-  let context = await (0, import_rxjs6.lastValueFrom)(
-    semiont.gather.annotation(annotationId2, resourceId2, { contextWindow: options.contextWindow })
+  let context = await (0, import_rxjs5.lastValueFrom)(
+    semiont.gather.annotation(resourceId3, annotationId3, { contextWindow: options.contextWindow })
   );
   if (options.userHint) {
     context = { ...context, userHint: options.userHint };
   }
-  const searchResult = await (0, import_rxjs6.firstValueFrom)(
-    semiont.match.search(resourceId2, rawAnnotationId, context, {
+  const searchResult = await (0, import_rxjs5.firstValueFrom)(
+    semiont.match.search(resourceId3, annotationId3, context, {
       limit: options.limit,
       useSemanticScoring: !options.noSemantic
     })
@@ -36296,9 +36503,9 @@ async function runBind(options) {
   const rawBusUrl = resolveBusUrl(options.bus);
   const { semiont } = loadCachedClient(rawBusUrl);
   const [rawResourceId, rawAnnotationId, targetResourceId] = options.args;
-  const resourceId2 = toResourceId5(rawResourceId);
-  const annotationId2 = toAnnotationId4(rawAnnotationId);
-  await semiont.bind.body(resourceId2, annotationId2, [{
+  const resourceId3 = toResourceId5(rawResourceId);
+  const annotationId3 = toAnnotationId4(rawAnnotationId);
+  await semiont.bind.body(resourceId3, annotationId3, [{
     op: "add",
     item: {
       type: "SpecificResource",
@@ -36392,7 +36599,7 @@ var beckonCmd = new CommandBuilder().name("beckon").description(
 
 // src/core/commands/browse.ts
 init_zod();
-var import_rxjs7 = __toESM(require_cjs(), 1);
+var import_rxjs6 = __toESM(require_cjs(), 1);
 var import_operators2 = __toESM(require_operators(), 1);
 init_command_definition();
 init_base_options_schema();
@@ -36441,15 +36648,15 @@ async function runBrowse(options) {
   if (subcommand === "resources") {
     const filters = { limit: options.limit };
     if (options.search) filters.search = options.search;
-    const items = await (0, import_rxjs7.firstValueFrom)(semiont.browse.resources(filters).pipe((0, import_operators2.filter)(defined)));
+    const items = await (0, import_rxjs6.firstValueFrom)(semiont.browse.resources(filters).pipe((0, import_operators2.filter)(defined)));
     result = items;
     label = `${items.length} resource${items.length !== 1 ? "s" : ""} found`;
   } else if (subcommand === "resource") {
     const id = toResourceId6(rawResourceId);
-    const resourceData = await (0, import_rxjs7.firstValueFrom)(semiont.browse.resource(id).pipe((0, import_operators2.filter)(defined)));
+    const resourceData = await (0, import_rxjs6.firstValueFrom)(semiont.browse.resource(id).pipe((0, import_operators2.filter)(defined)));
     if (options.annotations || options.references) {
-      const annotations = options.annotations ? await (0, import_rxjs7.firstValueFrom)(semiont.browse.annotations(id).pipe((0, import_operators2.filter)(defined))) : void 0;
-      const referencedBy = options.references ? await (0, import_rxjs7.firstValueFrom)(semiont.browse.referencedBy(id).pipe((0, import_operators2.filter)(defined))) : void 0;
+      const annotations = options.annotations ? await (0, import_rxjs6.firstValueFrom)(semiont.browse.annotations(id).pipe((0, import_operators2.filter)(defined))) : void 0;
+      const referencedBy = options.references ? await (0, import_rxjs6.firstValueFrom)(semiont.browse.referencedBy(id).pipe((0, import_operators2.filter)(defined))) : void 0;
       result = {
         ...resourceData,
         ...annotations ? { annotations } : {},
@@ -36460,13 +36667,13 @@ async function runBrowse(options) {
     }
     label = `${rawResourceId}: ${resourceData?.name ?? rawResourceId}`;
   } else if (subcommand === "annotation") {
-    const resourceId2 = toResourceId6(rawResourceId);
-    const annotationId2 = toAnnotationId5(rawAnnotationId);
-    result = await (0, import_rxjs7.firstValueFrom)(semiont.browse.annotation(resourceId2, annotationId2).pipe((0, import_operators2.filter)(defined)));
+    const resourceId3 = toResourceId6(rawResourceId);
+    const annotationId3 = toAnnotationId5(rawAnnotationId);
+    result = await (0, import_rxjs6.firstValueFrom)(semiont.browse.annotation(resourceId3, annotationId3).pipe((0, import_operators2.filter)(defined)));
     label = `${rawAnnotationId}: annotation on ${rawResourceId}`;
   } else if (subcommand === "references") {
     const id = toResourceId6(rawResourceId);
-    const refs = await (0, import_rxjs7.firstValueFrom)(semiont.browse.referencedBy(id).pipe((0, import_operators2.filter)(defined)));
+    const refs = await (0, import_rxjs6.firstValueFrom)(semiont.browse.referencedBy(id).pipe((0, import_operators2.filter)(defined)));
     result = refs;
     label = `${refs.length} resource${refs.length !== 1 ? "s" : ""} reference ${rawResourceId}`;
   } else if (subcommand === "events") {
@@ -36475,9 +36682,9 @@ async function runBrowse(options) {
     result = events;
     label = `${events.length} event${events.length !== 1 ? "s" : ""} for ${rawResourceId}`;
   } else if (subcommand === "history") {
-    const resourceId2 = toResourceId6(rawResourceId);
-    const annotationId2 = toAnnotationId5(rawAnnotationId);
-    result = await semiont.browse.annotationHistory(resourceId2, annotationId2);
+    const resourceId3 = toResourceId6(rawResourceId);
+    const annotationId3 = toAnnotationId5(rawAnnotationId);
+    result = await semiont.browse.annotationHistory(resourceId3, annotationId3);
     label = `history for annotation ${rawAnnotationId} on ${rawResourceId}`;
   } else if (subcommand === "files") {
     const dirPath = options.args[1];
@@ -36486,7 +36693,7 @@ async function runBrowse(options) {
     const entries = data?.entries ?? [];
     label = `${entries.length} entr${entries.length !== 1 ? "ies" : "y"} in ${dirPath ?? "/"}`;
   } else {
-    const tags = await (0, import_rxjs7.firstValueFrom)(semiont.browse.entityTypes().pipe((0, import_operators2.filter)(defined)));
+    const tags = await (0, import_rxjs6.firstValueFrom)(semiont.browse.entityTypes().pipe((0, import_operators2.filter)(defined)));
     result = tags;
     label = `${tags.length} entity type${tags.length !== 1 ? "s" : ""}`;
   }
@@ -36561,7 +36768,7 @@ init_zod();
 init_command_definition();
 init_base_options_schema();
 import { resourceId as toResourceId7 } from "@semiont/core";
-import { createActorVM as createActorVM3 } from "@semiont/api-client";
+import { createActorStateUnit } from "@semiont/api-client";
 var ListenOptionsSchema = ApiOptionsSchema.extend({
   args: external_exports.array(external_exports.string()).default([])
 }).superRefine((val, ctx) => {
@@ -36587,7 +36794,7 @@ var ALL_EVENT_TYPES = [
   "mark:unarchived",
   "mark:entity-tag-added",
   "mark:entity-tag-removed",
-  "mark:entity-type-added",
+  "frame:entity-type-added",
   "job:started",
   "job:progress",
   "job:completed",
@@ -36602,7 +36809,7 @@ async function runListen(options) {
   let eventCount = 0;
   const label = isResourceScoped ? `Listening for events on resource ${rawResourceId}` : "Listening for global events";
   if (!options.quiet) process.stderr.write(label + " (Ctrl-C to stop)\n");
-  const actor = createActorVM3({
+  const actor = createActorStateUnit({
     baseUrl: rawBusUrl,
     token,
     channels: isResourceScoped ? [] : [...ALL_EVENT_TYPES]
@@ -37365,15 +37572,15 @@ var OutputFormatter = class {
 `;
         }
       }
-      const resourceId2 = result.extensions?.resources || result.resourceId;
-      if (options.verbose && resourceId2) {
-        const resourceInfo = this.formatResourceId(resourceId2);
+      const resourceId3 = result.extensions?.resources || result.resourceId;
+      if (options.verbose && resourceId3) {
+        const resourceInfo = this.formatResourceId(resourceId3);
         if (resourceInfo) {
           output += `   ${c.dim}resource: ${resourceInfo}${c.reset}
 `;
         }
-        if (resourceId2.aws?.consoleUrl) {
-          output += `   ${c.cyan}console: ${resourceId2.aws.consoleUrl}${c.reset}
+        if (resourceId3.aws?.consoleUrl) {
+          output += `   ${c.cyan}console: ${resourceId3.aws.consoleUrl}${c.reset}
 `;
         }
       }
@@ -37549,43 +37756,43 @@ var OutputFormatter = class {
   /**
    * Format resource identifier for display
    */
-  static formatResourceId(resourceId2) {
-    if (!resourceId2) return "-";
-    if (resourceId2.aws) {
-      if (resourceId2.aws.arn) {
-        if (resourceId2.aws.arn.includes("/")) {
-          const parts = resourceId2.aws.arn.split("/");
-          return parts[parts.length - 1] || resourceId2.aws.arn;
-        }
-        const arnParts = resourceId2.aws.arn.split(":");
+  static formatResourceId(resourceId3) {
+    if (!resourceId3) return "-";
+    if (resourceId3.aws) {
+      if (resourceId3.aws.arn) {
+        if (resourceId3.aws.arn.includes("/")) {
+          const parts = resourceId3.aws.arn.split("/");
+          return parts[parts.length - 1] || resourceId3.aws.arn;
+        }
+        const arnParts = resourceId3.aws.arn.split(":");
         const resourcePart = arnParts[arnParts.length - 1] || "";
         if (resourcePart.includes("/")) {
           const subParts = resourcePart.split("/");
           return subParts[subParts.length - 1];
         }
-        return resourcePart || resourceId2.aws.name || "AWS";
+        return resourcePart || resourceId3.aws.name || "AWS";
       }
-      return resourceId2.aws.id || resourceId2.aws.name || "AWS";
+      return resourceId3.aws.id || resourceId3.aws.name || "AWS";
     }
-    if (resourceId2.container) {
-      const name = resourceId2.container.name || "";
-      const id = resourceId2.container.id ? resourceId2.container.id.substring(0, 12) : "";
+    if (resourceId3.container) {
+      const name = resourceId3.container.name || "";
+      const id = resourceId3.container.id ? resourceId3.container.id.substring(0, 12) : "";
       if (name && id) {
         return `${name}:${id}`;
       }
       return name || id || "Container";
     }
-    if (resourceId2.process) {
-      if (resourceId2.process.pid) {
-        return `PID:${resourceId2.process.pid}`;
+    if (resourceId3.process) {
+      if (resourceId3.process.pid) {
+        return `PID:${resourceId3.process.pid}`;
       }
-      return resourceId2.process.path || "Process";
+      return resourceId3.process.path || "Process";
     }
-    if (resourceId2.external) {
-      return resourceId2.external.endpoint || resourceId2.external.path || "External";
+    if (resourceId3.external) {
+      return resourceId3.external.endpoint || resourceId3.external.path || "External";
     }
-    if (resourceId2.mock) {
-      return resourceId2.mock.id || "Mock";
+    if (resourceId3.mock) {
+      return resourceId3.mock.id || "Mock";
     }
     return "-";
   }
@@ -37875,7 +38082,7 @@ async function generateGlobalHelp() {
 }
 
 // src/cli.ts
-var VERSION = "0.5.0";
+var VERSION = "0.5.2";
 function printVersion() {
   console.log(`Semiont CLI v${VERSION}`);
 }