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

package/dist/core.js

@@ -39,7 +39,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // ../package.json
-var version = "0.13.0-test-interpretation-1";
+var version = "0.13.0-test-interpretation-2";
 
 // src/utils.ts
 function isEmbedded() {
@@ -764,6 +764,14 @@ var Literal = class {
       const numberString = body.substring(7);
       return parseFloat(numberString);
     }
+    if (body.startsWith("boolean:")) {
+      const boolString = decodeURIComponent(body.substring(8));
+      if (boolString === "true")
+        return true;
+      if (boolString === "false")
+        return false;
+      throw new Error(`Can't parse boolean literal: ${boolString}`);
+    }
     if (body.startsWith("json:")) {
       const json = body.substring(5);
       return JSON.parse(decodeURIComponent(json));
@@ -1090,6 +1098,10 @@ var SHACLShape = class {
       }
       if (prop.writable !== void 0) {
         turtle += `    ad4m:writable ${prop.writable} ;
+`;
+      }
+      if (prop.identity !== void 0) {
+        turtle += `    ad4m:identity ${prop.identity} ;
 `;
       }
       turtle = turtle.slice(0, -2) + "\n";
@@ -1606,7 +1618,7 @@ var SHACLShape = class {
         hasValue: p.has_value,
         local: p.local,
         writable: p.writable,
-        resolveLanguage: p.resolve_language,
+        resolveLanguage: p.resolve_language ?? p.resolveLanguage,
         setter: p.setter,
         adder: p.adder,
         remover: p.remover,
@@ -1690,16 +1702,19 @@ function buildSHACL(subjectName, target, properties, allRelationsMeta, conforman
       name: propName,
       path: propMeta.through
     };
-    if (propMeta.resolveLanguage === "literal") {
-      propShape.datatype = "xsd://string";
-    } else if (propMeta.initial) {
-      const initialType = typeof obj[propName];
-      if (initialType === "number") {
-        propShape.datatype = "xsd://integer";
-      } else if (initialType === "boolean") {
-        propShape.datatype = "xsd://boolean";
-      } else if (initialType === "string") {
-        propShape.datatype = "xsd://string";
+    if (propMeta.datatype) {
+      propShape.datatype = propMeta.datatype;
+    } else {
+      const isLiteral = propMeta.resolveLanguage === void 0 || propMeta.resolveLanguage === "literal";
+      if ((propMeta.initial !== void 0 || isLiteral) && !propMeta.getter) {
+        const initialType = typeof obj[propName];
+        if (initialType === "number") {
+          propShape.datatype = "xsd://integer";
+        } else if (initialType === "boolean") {
+          propShape.datatype = "xsd://boolean";
+        } else if (initialType === "string" || isLiteral) {
+          propShape.datatype = "xsd://string";
+        }
       }
     }
     if (propMeta.required) {
@@ -1773,7 +1788,12 @@ function buildSHACL(subjectName, target, properties, allRelationsMeta, conforman
       name: relName,
       path: synthesizedPath
     };
-    relShape.nodeKind = "IRI";
+    if (relMeta.datatype) {
+      relShape.datatype = relMeta.datatype;
+      relShape.nodeKind = "Literal";
+    } else {
+      relShape.nodeKind = "IRI";
+    }
     relShape.relationKind = relMeta.kind;
     if (relMeta.kind === "hasOne" || relMeta.kind === "belongsToOne") {
       relShape.maxCount = 1;
@@ -2034,33 +2054,6 @@ function Optional(opts) {
     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;
@@ -2080,7 +2073,6 @@ function Property(opts) {
     ...opts,
     required,
     readOnly: opts.readOnly ?? false,
-    resolveLanguage: opts.resolveLanguage ?? "literal",
     initial: opts.initial ?? (required ? "literal:string:uninitialized" : void 0)
   });
 }
@@ -2122,7 +2114,8 @@ function HasMany(first, second) {
       local: opts.local,
       ...opts.getter && { getter: opts.getter },
       ...opts.filter !== void 0 && { filter: opts.filter },
-      ...opts.where && { where: opts.where }
+      ...opts.where && { where: opts.where },
+      ...opts.datatype && { datatype: opts.datatype }
     };
     const relKey = key;
     if (opts.through) {
@@ -2664,6 +2657,9 @@ var PerspectiveProxy = class {
   async addAutoProcessorEventListener(cb) {
     return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").addAutoProcessorEventListener(__classPrivateFieldGet$a(this, _PerspectiveProxy_handle, "f").uuid, cb);
   }
+  async addAutoProcessorNeighbourhoodStateListener(cb) {
+    return await __classPrivateFieldGet$a(this, _PerspectiveProxy_client, "f").addAutoProcessorNeighbourhoodStateListener(__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);
   }
@@ -3106,16 +3102,14 @@ var PerspectiveProxy = class {
       return null;
     }
     const flowUri = flowUriLinks[0].data.target;
-    const alternatePrefix = flowUri.endsWith("Flow") ? flowUri.slice(0, -4) + "." : flowUri + ".";
-    const sparqlQuery = `SELECT ?s ?p ?o WHERE {
-            ?s ?p ?o .
-            FILTER(?s = <${flowUri}> || STRSTARTS(STR(?s), "${alternatePrefix}"))
-        }`;
-    const sparqlResult = await this.querySparql(sparqlQuery);
-    const flowLinks = (sparqlResult || []).map((r) => ({
-      source: r.s,
-      predicate: r.p,
-      target: r.o
+    const flowLevelLinks = await this.get(new LinkQuery({ source: flowUri }));
+    const childUris = flowLevelLinks.filter((l) => l.data.predicate === "ad4m://hasState" || l.data.predicate === "ad4m://hasTransition").map((l) => l.data.target);
+    const childResults = await Promise.all(childUris.map((uri) => this.get(new LinkQuery({ source: uri }))));
+    const allExprs = [...flowLevelLinks, ...childResults.flat()];
+    const flowLinks = allExprs.map((l) => ({
+      source: l.data.source,
+      predicate: l.data.predicate,
+      target: l.data.target
     }));
     return SHACLFlow.fromLinks(flowLinks, flowUri);
   }
@@ -3793,9 +3787,9 @@ 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) {
+  async runInterpretation(uuid, transcript, basePrefix, classes, existingScope, mintScope) {
     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);
+    return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.runInterpretation", { uuid, transcript, basePrefix, classes, existingScope, mintScope }, RUN_INTERPRETATION_TIMEOUT_MS);
   }
   async addAutoProcessor(uuid, config) {
     return __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").call("perspective.addAutoProcessor", { uuid, ...config });
@@ -3815,7 +3809,20 @@ var PerspectiveClient = class {
         cb(data);
       }
     });
-    __classPrivateFieldGet$9(this, _PerspectiveClient_unsubscribers, "f").push(unsub);
+    let existing = __classPrivateFieldGet$9(this, _PerspectiveClient_linkUnsubscribers, "f").get(uuid) || [];
+    existing.push(unsub);
+    __classPrivateFieldGet$9(this, _PerspectiveClient_linkUnsubscribers, "f").set(uuid, existing);
+    await __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").waitForSubscription();
+  }
+  async addAutoProcessorNeighbourhoodStateListener(uuid, cb) {
+    const unsub = __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").subscribe((data) => {
+      if (data.type === "auto-processor-neighbourhood-state" && data.perspectiveUuid === uuid) {
+        cb(data);
+      }
+    });
+    let existing = __classPrivateFieldGet$9(this, _PerspectiveClient_linkUnsubscribers, "f").get(uuid) || [];
+    existing.push(unsub);
+    __classPrivateFieldGet$9(this, _PerspectiveClient_linkUnsubscribers, "f").set(uuid, existing);
     await __classPrivateFieldGet$9(this, _PerspectiveClient_apiClient, "f").waitForSubscription();
   }
   async addLinkExpression(uuid, link, status = "shared", batchId) {
@@ -9346,10 +9353,6 @@ function isArrayType(schema) {
 function isObjectType(schema) {
   return isSchemaType(schema, "object");
 }
-function isNumericType(schema) {
-  const normalized = normalizeSchemaType(schema.type);
-  return normalized === "number" || normalized === "integer";
-}
 function determineNamespace(schema, options) {
   if (options.namespace) {
     return options.namespace;
@@ -9471,10 +9474,6 @@ function buildModelFromJSONSchema(BaseClass, schema, options) {
         DynamicModelClass.prototype[setterName] = function() {
         };
       } else {
-        let resolveLanguage = getPropertyOption(propertyName, propertySchema, options, "resolveLanguage");
-        if (!resolveLanguage && options.resolveLanguage) {
-          resolveLanguage = options.resolveLanguage;
-        }
         const local = getPropertyOption(propertyName, propertySchema, options, "local");
         let readOnly = getPropertyOption(propertyName, propertySchema, options, "readOnly");
         if (readOnly === void 0) {
@@ -9483,16 +9482,10 @@ function buildModelFromJSONSchema(BaseClass, schema, options) {
         }
         const writable = !readOnly;
         let initial = getPropertyOption(propertyName, propertySchema, options, "initial");
-        if (isObjectType(propertySchema) && !resolveLanguage) {
-          resolveLanguage = "literal";
+        const resolveLanguage = getPropertyOption(propertyName, propertySchema, options, "resolveLanguage");
+        if (isObjectType(propertySchema)) {
           console.warn(`Property "${propertyName}" is an object type. It will be stored as JSON. Consider flattening complex objects for better semantic querying.`);
         }
-        if ((resolveLanguage === void 0 || resolveLanguage === null) && isNumericType(propertySchema)) {
-          resolveLanguage = "literal";
-        }
-        if (resolveLanguage === void 0 || resolveLanguage === null) {
-          resolveLanguage = "literal";
-        }
         if (isRequired && !initial) {
           if (isObjectType(propertySchema)) {
             initial = "literal:json:{}";
@@ -9504,7 +9497,7 @@ function buildModelFromJSONSchema(BaseClass, schema, options) {
           through: predicate,
           required: isRequired,
           writable,
-          ...resolveLanguage && { resolveLanguage },
+          ...resolveLanguage !== void 0 && { resolveLanguage },
           ...local !== void 0 && { local },
           ...initial && { initial }
         };
@@ -9567,13 +9560,43 @@ function hasJsOnlyWhereFilters(metadata, allRelationsMetadata, where) {
   }
   return false;
 }
-function isLiteralStoredProperty(propMeta) {
-  if (propMeta.flag)
+function looksLikeUri(value) {
+  if (!/^[a-zA-Z][a-zA-Z0-9+\-._]*:/.test(value))
     return false;
-  if (propMeta.resolveLanguage && propMeta.resolveLanguage !== "literal")
+  if (/[\s<>{}"\u0000-\u001F\u007F-\u009F]/.test(value))
     return false;
   return true;
 }
+function valueToLiteralIri(value) {
+  if (typeof value === "string") {
+    if (looksLikeUri(value))
+      return value;
+    return Literal.from(value).toUrl();
+  }
+  if (typeof value === "number") {
+    return Literal.from(value).toUrl();
+  }
+  if (typeof value === "boolean") {
+    return Literal.from(value).toUrl();
+  }
+  if (value !== null && typeof value === "object") {
+    return Literal.from(value).toUrl();
+  }
+  return Literal.from(String(value)).toUrl();
+}
+function effectiveLiteralStorage(meta) {
+  const lang = meta.resolveLanguage;
+  if (lang === void 0)
+    return { kind: "deterministic" };
+  if (lang === "literal")
+    return { kind: "envelope" };
+  return { kind: "custom", language: lang };
+}
+function isLiteralStoredProperty(propMeta) {
+  if (propMeta.flag)
+    return false;
+  return effectiveLiteralStorage(propMeta).kind === "deterministic";
+}
 function escapeSPARQL(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\0/g, "").replace(/\f/g, "\\u000C");
 }
@@ -10309,7 +10332,7 @@ var Ad4mModel = class {
               predicate,
               required: isRequired,
               readOnly: propertySchema["x-ad4m"]?.writable === false,
-              ...propertySchema["x-ad4m"]?.resolveLanguage && { resolveLanguage: propertySchema["x-ad4m"].resolveLanguage },
+              ...propertySchema["x-ad4m"]?.resolveLanguage !== void 0 && { resolveLanguage: propertySchema["x-ad4m"].resolveLanguage },
               ...propertySchema["x-ad4m"]?.initial && { initial: propertySchema["x-ad4m"].initial },
               ...propertySchema["x-ad4m"]?.local !== void 0 && { local: propertySchema["x-ad4m"].local }
             };
@@ -10325,7 +10348,7 @@ var Ad4mModel = class {
   }
   constructor(perspective, baseExpression) {
     this._snapshot = null;
-    this._baseExpression = baseExpression ? baseExpression : Literal.from(makeRandomId(24)).toUrl();
+    this._baseExpression = baseExpression ? baseExpression : `ad4m://obj/${makeRandomId(24)}`;
     this._perspective = perspective;
   }
   get id() {
@@ -10615,12 +10638,16 @@ var Ad4mModel = class {
       return;
     }
     const actions = this.generatePropertySetterAction(key, metadata);
-    let resolveLanguage = metadata.resolveLanguage;
     if (value === void 0 || value === null || value === "") {
       return;
     }
-    if (resolveLanguage) {
-      value = await this._perspective.createExpression(value, resolveLanguage);
+    const mode = effectiveLiteralStorage(metadata);
+    if (mode.kind === "custom") {
+      value = await this._perspective.createExpression(value, mode.language);
+    } else if (mode.kind === "envelope") {
+      value = await this._perspective.createExpression(value, "literal");
+    } else {
+      value = valueToLiteralIri(value);
     }
     await this._perspective.executeAction(actions, this._baseExpression, [{ name: "value", value }], batchId);
   }
@@ -10693,14 +10720,14 @@ var Ad4mModel = class {
     }
     const metadata = this.constructor.getModelMetadata();
     const hasConstructor = Object.values(metadata.properties).some((p) => p.required || p.flag || p.initial !== void 0);
-    const deferredResolveLanguageProps = [];
+    const deferredExpressionProps = [];
     if (hasConstructor) {
       const initialValues = {};
       for (const [key, value] of Object.entries(this)) {
         if (value !== void 0 && value !== null && !(Array.isArray(value) && value.length > 0) && !value?.action) {
           const propMeta = metadata.properties[key];
-          if (propMeta?.resolveLanguage && propMeta.resolveLanguage !== "literal" && typeof value === "object") {
-            deferredResolveLanguageProps.push(key);
+          if (propMeta && effectiveLiteralStorage(propMeta).kind !== "deterministic") {
+            deferredExpressionProps.push(key);
             continue;
           }
           initialValues[key] = value;
@@ -10710,7 +10737,7 @@ var Ad4mModel = class {
       await this.perspective.createSubject(className, this._baseExpression, initialValues, batchId);
     }
     await this.innerUpdate(!hasConstructor, batchId);
-    for (const key of deferredResolveLanguageProps) {
+    for (const key of deferredExpressionProps) {
       const value = this[key];
       if (value !== void 0 && value !== null) {
         await this.setProperty(key, value, batchId);
@@ -11126,7 +11153,6 @@ var __metadata = function(k, v) {
 var AutoProcessorConfig = class AutoProcessorConfig2 extends Ad4mModel {
   constructor() {
     super(...arguments);
-    this.type = "ad4m://AutoProcessor";
     this.processorId = "";
     this.sourceScopeQuery = "";
     this.interpretationClasses = [];
@@ -11135,10 +11161,6 @@ var AutoProcessorConfig = class AutoProcessorConfig2 extends Ad4mModel {
     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)
@@ -11148,11 +11170,11 @@ __decorate([
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "sourceScopeQuery", void 0);
 __decorate([
-  Optional({ through: "ad4m://base_prefix", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://base_prefix" }),
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "basePrefix", void 0);
 __decorate([
-  HasMany({ through: "ad4m://interpretation_class" }),
+  HasMany({ through: "ad4m://interpretation_class", datatype: "xsd:string" }),
   __metadata("design:type", Array)
 ], AutoProcessorConfig.prototype, "interpretationClasses", void 0);
 __decorate([
@@ -11160,7 +11182,7 @@ __decorate([
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "debounceMs", void 0);
 __decorate([
-  Optional({ through: "ad4m://batch_min", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://batch_min" }),
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "batchMin", void 0);
 __decorate([
@@ -11168,7 +11190,7 @@ __decorate([
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "batchMax", void 0);
 __decorate([
-  Optional({ through: "ad4m://max_wait_ms", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://max_wait_ms" }),
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "maxWaitMs", void 0);
 __decorate([
@@ -11176,52 +11198,75 @@ __decorate([
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "claimTtlMs", void 0);
 __decorate([
-  Optional({ through: "ad4m://source_window_ms", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://source_window_ms" }),
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "sourceWindowMs", void 0);
 __decorate([
-  Optional({ through: "ad4m://dedup_strategy", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://dedup_strategy" }),
   __metadata("design:type", String)
 ], AutoProcessorConfig.prototype, "dedupStrategy", void 0);
+__decorate([
+  Optional({ through: "ad4m://existing_scope" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "existingScope", void 0);
+__decorate([
+  Optional({ through: "ad4m://mint_scope" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "mintScope", void 0);
+__decorate([
+  Optional({ through: "ad4m://debug_mode", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "debugMode", void 0);
+__decorate([
+  Optional({ through: "ad4m://persist_debug", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "persistDebug", void 0);
+__decorate([
+  Optional({ through: "ad4m://emit_debug_events", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], AutoProcessorConfig.prototype, "emitDebugEvents", void 0);
 AutoProcessorConfig = __decorate([
-  Model$1({ name: "AutoProcessorConfig" })
+  Model$1({ name: "AutoProcessor" })
 ], 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" }),
+  Optional({ through: "ad4m://interp/model" }),
   __metadata("design:type", String)
 ], InterpretationRun.prototype, "model", void 0);
 __decorate([
-  Optional({ through: "ad4m://interp/prompt_version", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://interp/prompt_version" }),
   __metadata("design:type", String)
 ], InterpretationRun.prototype, "promptVersion", void 0);
 __decorate([
-  Optional({ through: "ad4m://interp/ran_at", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://interp/ran_at" }),
   __metadata("design:type", String)
 ], InterpretationRun.prototype, "ranAt", void 0);
 __decorate([
-  Optional({ through: "ad4m://interp/processor", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://interp/processor" }),
   __metadata("design:type", String)
 ], InterpretationRun.prototype, "processor", void 0);
 __decorate([
-  HasMany({ through: "ad4m://interp/sources" }),
+  HasMany({ through: "ad4m://interp/sources", datatype: "xsd:string" }),
   __metadata("design:type", Array)
 ], InterpretationRun.prototype, "sources", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/debug_prompt", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "debugPrompt", void 0);
+__decorate([
+  Optional({ through: "ad4m://interp/debug_response", resolveLanguage: "literal" }),
+  __metadata("design:type", String)
+], InterpretationRun.prototype, "debugResponse", void 0);
 InterpretationRun = __decorate([
   Model$1({ name: "InterpretationRun" })
 ], InterpretationRun);
@@ -11232,11 +11277,11 @@ var InterpretationOverlay = class InterpretationOverlay2 extends Ad4mModel {
   }
 };
 __decorate([
-  Property({ through: "ad4m://interp/kind", required: true, resolveLanguage: "literal" }),
+  Property({ through: "ad4m://interp/kind", required: true }),
   __metadata("design:type", String)
 ], InterpretationOverlay.prototype, "kind", void 0);
 __decorate([
-  Optional({ through: "ad4m://interp/run", resolveLanguage: "literal" }),
+  Optional({ through: "ad4m://interp/run" }),
   __metadata("design:type", String)
 ], InterpretationOverlay.prototype, "run", void 0);
 InterpretationOverlay = __decorate([