@coasys/ad4m-connect 0.13.0-test-9 → 0.13.0-test-interpretation-1

package/dist/core.js

@@ -39,7 +39,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // ../package.json
-var version = "0.13.0-test-9";
+var version = "0.13.0-test-interpretation-1";
 
 // src/utils.ts
 function isEmbedded() {
@@ -395,15 +395,16 @@ var ApiClient = class {
     if (this._wsReady)
       await this._wsReady;
   }
-  async call(type, params) {
+  async call(type, params, timeoutMs) {
     await this._ready();
     const id = nextId();
     const message = { id, type, params: params || {} };
+    const effectiveTimeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this._pendingCalls.delete(id);
-        reject(new RpcError(408, `RPC call '${type}' timed out after ${DEFAULT_TIMEOUT_MS}ms`));
-      }, DEFAULT_TIMEOUT_MS);
+        reject(new RpcError(408, `RPC call '${type}' timed out after ${effectiveTimeout}ms`));
+      }, effectiveTimeout);
       this._pendingCalls.set(id, {
         resolve,
         reject,
@@ -1126,6 +1127,13 @@ var SHACLShape = class {
         target: `literal:string:${JSON.stringify(this.destructor_actions)}`
       });
     }
+    if (this.interpretationHint) {
+      links.push({
+        source: this.nodeShapeUri,
+        predicate: "ad4m://interpretation_hint",
+        target: `literal:string:${this.interpretationHint}`
+      });
+    }
     for (let i = 0; i < this.properties.length; i++) {
       const prop = this.properties[i];
       let propShapeId;
@@ -1314,6 +1322,20 @@ var SHACLShape = class {
           target: `literal:string:${JSON.stringify(prop.transform)}`
         });
       }
+      if (prop.interpretationHint) {
+        links.push({
+          source: propShapeId,
+          predicate: "ad4m://interpretation_hint",
+          target: `literal:string:${prop.interpretationHint}`
+        });
+      }
+      if (prop.identity) {
+        links.push({
+          source: propShapeId,
+          predicate: "ad4m://identity",
+          target: `literal:string:true`
+        });
+      }
     }
     return links;
   }
@@ -1336,6 +1358,10 @@ var SHACLShape = class {
       } catch (e) {
       }
     }
+    const classHintLink = links.find((l) => l.source === shapeUri && l.predicate === "ad4m://interpretation_hint");
+    if (classHintLink) {
+      shape.interpretationHint = classHintLink.target.replace(/^literal:\/\/string:|^literal:string:/, "");
+    }
     const propShapeLinks = links.filter((l) => l.source === shapeUri && l.predicate === "sh://property");
     for (const propLink of propShapeLinks) {
       const propShapeId = propLink.target;
@@ -1496,6 +1522,14 @@ var SHACLShape = class {
           val = val.substring(8);
         prop.filter = val === "true";
       }
+      const interpretationHintLink = links.find((l) => l.source === propShapeId && l.predicate === "ad4m://interpretation_hint");
+      if (interpretationHintLink) {
+        prop.interpretationHint = interpretationHintLink.target.replace(/^literal:\/\/string:|^literal:string:/, "");
+      }
+      const identityLink = links.find((l) => l.source === propShapeId && l.predicate === "ad4m://identity");
+      if (identityLink) {
+        prop.identity = identityLink.target.replace(/^literal:\/\/string:|^literal:string:/, "") === "true";
+      }
       const transformLink = links.find((l) => l.source === propShapeId && l.predicate === "ad4m://transform");
       if (transformLink) {
         const jsonStr = transformLink.target.replace(/^literal:\/\/string:|^literal:string:/, "");
@@ -1518,6 +1552,7 @@ var SHACLShape = class {
       node_shape_uri: this.nodeShapeUri,
       target_class: this.targetClass,
       parent_shapes: this.parentShapes.length > 0 ? this.parentShapes : void 0,
+      interpretation_hint: this.interpretationHint,
       properties: this.properties.map((p) => ({
         path: p.path,
         name: p.name,
@@ -1544,7 +1579,9 @@ var SHACLShape = class {
         where_filter: p.whereFilter,
         where_predicates: p.wherePredicates,
         filter: p.filter,
-        transform: p.transform
+        transform: p.transform,
+        interpretation_hint: p.interpretationHint,
+        identity: p.identity
       })),
       constructor_actions: this.constructor_actions,
       destructor_actions: this.destructor_actions
@@ -1582,7 +1619,9 @@ var SHACLShape = class {
         whereFilter: p.where_filter,
         wherePredicates: p.where_predicates,
         filter: p.filter,
-        transform: p.transform
+        transform: p.transform,
+        interpretationHint: p.interpretation_hint,
+        identity: p.identity
       });
     }
     if (json.constructor_actions) {
@@ -1596,10 +1635,13 @@ var SHACLShape = class {
         shape.addParentShape(ps);
       }
     }
+    if (json.interpretation_hint) {
+      shape.interpretationHint = json.interpretation_hint;
+    }
     return shape;
   }
 };
-function buildSHACL(subjectName, target, properties, allRelationsMeta, conformanceFilterFn, seedCache) {
+function buildSHACL(subjectName, target, properties, allRelationsMeta, conformanceFilterFn, seedCache, interpretationHint) {
   const obj = target.prototype;
   let namespace = "ad4m://";
   if (Object.keys(properties).length > 0) {
@@ -1622,6 +1664,9 @@ function buildSHACL(subjectName, target, properties, allRelationsMeta, conforman
   const shapeUri = `${namespace}${subjectName}Shape`;
   const targetClass = `${namespace}${subjectName}`;
   const shape = new SHACLShape(shapeUri, targetClass);
+  if (interpretationHint) {
+    shape.interpretationHint = interpretationHint;
+  }
   if (seedCache) {
     seedCache({ shape, name: subjectName });
   }
@@ -1682,6 +1727,12 @@ function buildSHACL(subjectName, target, properties, allRelationsMeta, conforman
     if (propMeta.transform) {
       propShape.transform = propMeta.transform;
     }
+    if (propMeta.interpretationHint) {
+      propShape.interpretationHint = propMeta.interpretationHint;
+    }
+    if (propMeta.identity) {
+      propShape.identity = true;
+    }
     if (propMeta.prologSetter) {
       console.warn(`[SHACL Generation] Custom Prolog setter for property '${propName}' in class '${subjectName}' is not yet supported. The property will be created without setter actions. Consider using standard writable properties or provide explicit SHACL JSON.`);
     } else if (propMeta.writable && propMeta.through) {
@@ -1955,6 +2006,61 @@ function buildConformanceFilter(relationPredicate, targetClass) {
     return void 0;
   }
 }
+function applyPropertyMetadata(opts) {
+  return function(target, key) {
+    const writable = opts.readOnly ? false : opts.through ? true : false;
+    if (opts.required && !opts.initial) {
+      throw new Error("SubjectProperty requires an 'initial' option if 'required' is true");
+    }
+    if (!opts.through && !opts.prologGetter && !opts.getter) {
+      throw new Error("SubjectProperty requires either 'through' or 'prologGetter' or 'getter' option");
+    }
+    const ctor = target.constructor;
+    if (!propertyRegistry.has(ctor))
+      propertyRegistry.set(ctor, {});
+    propertyRegistry.get(ctor)[key] = { ...opts, writable };
+    if (writable) {
+      const value = key;
+      target[`set${capitalize(value)}`] = () => {
+      };
+    }
+    Object.defineProperty(target, key, { configurable: true, writable: true });
+  };
+}
+function Optional(opts) {
+  return applyPropertyMetadata({
+    ...opts,
+    required: opts.required ?? false,
+    readOnly: opts.readOnly ?? false
+  });
+}
+function Flag(opts) {
+  return function(target, key) {
+    if (!opts.through && !opts.value) {
+      throw new Error("SubjectFlag requires a 'through' and 'value' option");
+    }
+    if (!opts.through) {
+      throw new Error("SubjectFlag requires a 'through' option");
+    }
+    if (!opts.value) {
+      throw new Error("SubjectFlag requires a 'value' option");
+    }
+    const entry = {
+      through: opts.through,
+      required: true,
+      initial: opts.value,
+      flag: true,
+      readOnly: true,
+      writable: false
+    };
+    const ctor = target.constructor;
+    if (!propertyRegistry.has(ctor))
+      propertyRegistry.set(ctor, {});
+    propertyRegistry.get(ctor)[key] = entry;
+    target[key] = opts.value;
+    Object.defineProperty(target, key, { configurable: true, writable: true });
+  };
+}
 function Model$1(opts) {
   return function(target) {
     target.prototype.className = opts.name;
@@ -1963,11 +2069,76 @@ function Model$1(opts) {
       return buildSDNA(opts.name, target.prototype, getPropertiesMetadata(target), getRelationsMetadata(target));
     };
     target.generateSHACL = function() {
-      return getMemoizedSHACL(target, (seed) => buildSHACL(opts.name, target, getPropertiesMetadata(target), getRelationsMetadata(target), buildConformanceFilter, seed));
+      return getMemoizedSHACL(target, (seed) => buildSHACL(opts.name, target, getPropertiesMetadata(target), getRelationsMetadata(target), buildConformanceFilter, seed, opts.interpretationHint));
     };
     Object.defineProperty(target, "type", { configurable: true });
   };
 }
+function Property(opts) {
+  const required = opts.required ?? false;
+  return applyPropertyMetadata({
+    ...opts,
+    required,
+    readOnly: opts.readOnly ?? false,
+    resolveLanguage: opts.resolveLanguage ?? "literal",
+    initial: opts.initial ?? (required ? "literal:string:uninitialized" : void 0)
+  });
+}
+function resolveRelationArgs(first, second) {
+  const opts = typeof first === "function" ? { ...second || {}, target: first } : first;
+  if (opts.getter) {
+    if (opts.through) {
+      throw new Error("Relation decorator: `getter` and `through` are mutually exclusive. Use `getter` alone for custom read-only relations, or `through` (with optional `target`) for standard link-based relations.");
+    }
+    if (opts.target) {
+      throw new Error("Relation decorator: `getter` and `target` are mutually exclusive. `target` auto-generates a conformance getter from the model shape; providing both is contradictory.");
+    }
+    if (opts.where) {
+      throw new Error("Relation decorator: `where` and `getter` are mutually exclusive. Use `where` for DSL-based filtering, or `getter` for raw getter expression.");
+    }
+    return opts;
+  }
+  if (!opts.through) {
+    opts.through = "ad4m://has_child";
+  }
+  if (opts.where) {
+    if (opts.filter === false) {
+      throw new Error("Relation decorator: `where` and `filter: false` are contradictory. `where` adds filtering constraints; `filter: false` disables filtering.");
+    }
+  }
+  return opts;
+}
+function HasMany(first, second) {
+  const opts = resolveRelationArgs(first, second);
+  return function(target, key) {
+    const ctor = target.constructor;
+    if (!relationRegistry.has(ctor))
+      relationRegistry.set(ctor, {});
+    const map = relationRegistry.get(ctor);
+    map[key] = {
+      predicate: opts.through,
+      target: opts.target,
+      kind: "hasMany",
+      local: opts.local,
+      ...opts.getter && { getter: opts.getter },
+      ...opts.filter !== void 0 && { filter: opts.filter },
+      ...opts.where && { where: opts.where }
+    };
+    const relKey = key;
+    if (opts.through) {
+      target[`add${capitalize(relKey)}`] = async function(arg, batchId) {
+        return this.addRelationValue(relKey, arg, batchId);
+      };
+      target[`remove${capitalize(relKey)}`] = async function(arg, batchId) {
+        return this.removeRelationValue(relKey, arg, batchId);
+      };
+      target[`set${capitalize(relKey)}`] = async function(arg, batchId) {
+        return this.setRelationValues(relKey, arg, batchId);
+      };
+    }
+    Object.defineProperty(target, relKey, { configurable: true, writable: true });
+  };
+}
 var cache = /* @__PURE__ */ new Map();
 var DEFAULT_TTL_MS = 200;
 function makeKey(perspectiveUUID, queryText) {
@@ -2475,6 +2646,24 @@ var PerspectiveProxy = class {
   async get(query) {
     return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").queryLinks(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, query);
   }
+  async runInterpretation(transcript, basePrefix, classes) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").runInterpretation(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, transcript, basePrefix, classes);
+  }
+  async addAutoProcessor(config) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").addAutoProcessor(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, config);
+  }
+  async interpretationOverlays() {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").interpretationOverlays(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid);
+  }
+  async acceptInterpretation(base, property) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").acceptInterpretation(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, base, property);
+  }
+  async rejectInterpretation(base, property) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").rejectInterpretation(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, base, property);
+  }
+  async addAutoProcessorEventListener(cb) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").addAutoProcessorEventListener(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, cb);
+  }
   async infer(query) {
     return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").queryProlog(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, query);
   }
@@ -3604,6 +3793,31 @@ var PerspectiveClient = class {
   async linkMutations(uuid, mutations, status) {
     return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.linkMutations", { uuid, mutations, status });
   }
+  async runInterpretation(uuid, transcript, basePrefix, classes) {
+    const RUN_INTERPRETATION_TIMEOUT_MS = 20 * 60 * 1e3;
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.runInterpretation", { uuid, transcript, basePrefix, classes }, RUN_INTERPRETATION_TIMEOUT_MS);
+  }
+  async addAutoProcessor(uuid, config) {
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.addAutoProcessor", { uuid, ...config });
+  }
+  async interpretationOverlays(uuid) {
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.interpretationOverlays", { uuid });
+  }
+  async acceptInterpretation(uuid, base, property) {
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.acceptInterpretation", { uuid, base, property });
+  }
+  async rejectInterpretation(uuid, base, property) {
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.rejectInterpretation", { uuid, base, property });
+  }
+  async addAutoProcessorEventListener(uuid, cb) {
+    const unsub = __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").subscribe((data) => {
+      if (data.type === "auto-processor-event" && data.perspectiveUuid === uuid) {
+        cb(data);
+      }
+    });
+    __classPrivateFieldGet$9(this, _PerspectiveClient_unsubscribers, "f").push(unsub);
+    await __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").waitForSubscription();
+  }
   async addLinkExpression(uuid, link, status = "shared", batchId) {
     return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.addLinkExpression", { uuid, link, status, batchId });
   }
@@ -9035,7 +9249,7 @@ var AIClient = class {
   async embed(modelId, text) {
     const aiEmbed = await __classPrivateFieldGet$2(this, _AIClient_apiClient, "f").call("ai.embed", { modelId, text });
     const compressed = base64Js.toByteArray(aiEmbed);
-    const decompressed = JSON.parse(pako.inflate(compressed, { to: "string" }));
+    const decompressed = JSON.parse(new TextDecoder().decode(pako.inflate(compressed)));
     return decompressed;
   }
   async openTranscriptionStream(modelId, streamCallback, params) {
@@ -10895,6 +11109,139 @@ var PerspectiveState;
   PerspectiveState2["LinkLanguageInstalledButNotSynced"] = "LINK_LANGUAGE_INSTALLED_BUT_NOT_SYNCED";
   PerspectiveState2["Synced"] = "SYNCED";
 })(PerspectiveState || (PerspectiveState = {}));
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var AutoProcessorConfig = class AutoProcessorConfig2 extends Ad4mModel {
+  constructor() {
+    super(...arguments);
+    this.type = "ad4m://AutoProcessor";
+    this.processorId = "";
+    this.sourceScopeQuery = "";
+    this.interpretationClasses = [];
+    this.debounceMs = "200";
+    this.batchMax = "32";
+    this.claimTtlMs = "60000";
+  }
+};
+__decorate([
+  Flag({ through: "rdf://type", value: "ad4m://AutoProcessor" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "type", void 0);
+__decorate([
+  Property({ through: "ad4m://processor_id", required: true, identity: true }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "processorId", void 0);
+__decorate([
+  Property({ through: "ad4m://source_scope_query", required: true }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "sourceScopeQuery", void 0);
+__decorate([
+  Optional({ through: "ad4m://base_prefix", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "basePrefix", void 0);
+__decorate([
+  HasMany({ through: "ad4m://interpretation_class" }),
+  __metadata("design:type", Array)
+], AutoProcessorConfig.prototype, "interpretationClasses", void 0);
+__decorate([
+  Property({ through: "ad4m://debounce_ms", required: true }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "debounceMs", void 0);
+__decorate([
+  Optional({ through: "ad4m://batch_min", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "batchMin", void 0);
+__decorate([
+  Property({ through: "ad4m://batch_max", required: true }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "batchMax", void 0);
+__decorate([
+  Optional({ through: "ad4m://max_wait_ms", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "maxWaitMs", void 0);
+__decorate([
+  Property({ through: "ad4m://claim_ttl_ms", required: true }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "claimTtlMs", void 0);
+__decorate([
+  Optional({ through: "ad4m://source_window_ms", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "sourceWindowMs", void 0);
+__decorate([
+  Optional({ through: "ad4m://dedup_strategy", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "dedupStrategy", void 0);
+AutoProcessorConfig = __decorate([
+  Model$1({ name: "AutoProcessorConfig" })
+], AutoProcessorConfig);
+var InterpretationRun = class InterpretationRun2 extends Ad4mModel {
+  constructor() {
+    super(...arguments);
+    this.type = "ad4m://interpretation-run";
+    this.runId = "";
+    this.sources = [];
+  }
+};
+__decorate([
+  Flag({ through: "ad4m://type", value: "ad4m://interpretation-run" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "type", void 0);
+__decorate([
+  Property({ through: "ad4m://interp/run_id", required: true, identity: true }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "runId", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/model", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "model", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/prompt_version", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "promptVersion", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/ran_at", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "ranAt", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/processor", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "processor", void 0);
+__decorate([
+  HasMany({ through: "ad4m://interp/sources" }),
+  __metadata("design:type", Array)
+], InterpretationRun.prototype, "sources", void 0);
+InterpretationRun = __decorate([
+  Model$1({ name: "InterpretationRun" })
+], InterpretationRun);
+var InterpretationOverlay = class InterpretationOverlay2 extends Ad4mModel {
+  constructor() {
+    super(...arguments);
+    this.kind = "";
+  }
+};
+__decorate([
+  Property({ through: "ad4m://interp/kind", required: true, resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationOverlay.prototype, "kind", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/run", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationOverlay.prototype, "run", void 0);
+InterpretationOverlay = __decorate([
+  Model$1({ name: "InterpretationOverlay" })
+], InterpretationOverlay);
 var PerspectiveDiffExpression = class extends ExpressionGeneric() {
 };
 var _SmartLiteral_perspective;