@granular-software/sdk 0.4.11 → 0.4.13

package/dist/index.js

@@ -1,6 +1,8 @@
 'use strict';
 
 var Automerge = require('@automerge/automerge');
+var metamodelEffectBehaviors = require('@granular-software/metamodel-effect-behaviors');
+var metamodelPresetDefault = require('@granular-software/metamodel-preset-default');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -4650,7 +4652,7 @@ var Session = class {
    * Respond to a prompt request from the sandbox
    */
   async answerPrompt(promptId, answer) {
-    await this.client.call("prompt.answer", { promptId, value: answer });
+    await this.client.call("prompt.answer", { promptId, answer, value: answer });
   }
   /**
    * Get the current list of available effects.
@@ -4967,13 +4969,31 @@ import { ${allImports} } from "./sandbox-tools";
     });
   }
   setupEventHandlers() {
+    this.client.on("open", (payload) => this.emit("open", payload || {}));
     this.client.on("sync", (doc) => {
       this.currentDomainRevision = this.extractDomainRevisionFromDoc(doc);
       this.emit("sync", doc);
       this.checkForToolChanges();
     });
-    this.client.on("prompt", (prompt) => this.emit("prompt", prompt));
+    const emitPrompt = (payload) => {
+      const raw = payload;
+      const prompt = raw.prompt || {
+        id: typeof raw.id === "string" ? raw.id : String(raw.promptId || ""),
+        type: raw.type === "confirm" || raw.type === "choice" || raw.type === "input" ? raw.type : raw.promptType === "confirm" || raw.promptType === "choice" ? raw.promptType : "input",
+        title: typeof raw.title === "string" ? raw.title : "Input required",
+        message: typeof raw.message === "string" ? raw.message : "",
+        options: raw.options,
+        defaultValue: raw.defaultValue,
+        placeholder: raw.placeholder,
+        allowEmpty: raw.allowEmpty,
+        metadata: raw.metadata
+      };
+      this.emit("prompt", prompt);
+    };
+    this.client.on("prompt", emitPrompt);
+    this.client.on("prompt.request", emitPrompt);
     this.client.on("disconnect", (payload) => this.emit("disconnect", payload || {}));
+    this.client.on("reconnect_error", (payload) => this.emit("reconnect_error", payload || {}));
     this.client.on("job.status", (data) => {
       this.emit("job:status", data);
     });
@@ -5045,6 +5065,8 @@ function normalizeJobStatus(status) {
     case "failed":
     case "running":
     case "queued":
+    case "awaitingTool":
+    case "awaitingHuman":
     case "succeeded":
     case "timeout":
     case "canceled":
@@ -5179,6 +5201,19 @@ var JobImplementation = class {
     this.client.on(`job.${id}.error`, (error) => {
       this.finalize("failed", void 0, error);
     });
+    this.client.on("job.status", (data) => {
+      const jobData = data;
+      if (jobData.jobId !== id) {
+        return;
+      }
+      const normalizedStatus = normalizeJobStatus(jobData.status);
+      this.status = normalizedStatus;
+      this.metadata.status = normalizedStatus;
+      if (normalizedStatus === "running") {
+        this.markStarted();
+      }
+      this.emit("status", normalizedStatus);
+    });
     this.client.on("job.completed", (data) => {
       const jobData = data;
       if (jobData.jobId === id) {
@@ -5372,6 +5407,123 @@ function resolveApiUrl(explicitApiUrl, mode) {
   }
   return resolveEndpointMode(mode) === "local" ? LOCAL_API_URL : PRODUCTION_API_URL;
 }
+function computeEffectKey(effect) {
+  const attachedClass = effect.className?.trim();
+  if (!attachedClass) {
+    return `global:${effect.name}`;
+  }
+  return effect.static ? `class:${attachedClass}:static:${effect.name}` : `class:${attachedClass}:instance:${effect.name}`;
+}
+function normalizeEffectBehaviors(value) {
+  return metamodelEffectBehaviors.normalizeEffectBehaviorSummary(
+    value
+  ) || {};
+}
+function resolveInvocationMode(context) {
+  const mode = context?.invocation?.mode;
+  if (mode === "dryRun" || mode === "reverse") {
+    return mode;
+  }
+  return "execute";
+}
+function resolveReverseEffect(effectMap, currentEffect, request, behaviors) {
+  const explicitReverseHandler = request.context?.invocation?.reverseHandler?.trim();
+  const configuredReverseHandler = behaviors.reverse?.handler?.trim();
+  const reverseHandler = explicitReverseHandler || configuredReverseHandler;
+  if (!reverseHandler) {
+    return void 0;
+  }
+  if (reverseHandler.includes(":")) {
+    return effectMap.get(reverseHandler);
+  }
+  const directMatch = effectMap.get(reverseHandler);
+  if (directMatch) {
+    return directMatch;
+  }
+  const candidateKeys = [
+    computeEffectKey({
+      name: reverseHandler,
+      className: currentEffect.className,
+      static: currentEffect.static
+    }),
+    computeEffectKey({
+      name: reverseHandler
+    })
+  ];
+  for (const candidateKey of candidateKeys) {
+    const candidate = effectMap.get(candidateKey);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveHandlerForMode(effectMap, effect, request) {
+  const behaviors = normalizeEffectBehaviors(request.context?.behaviors || effect.metamodels || void 0);
+  const mode = resolveInvocationMode(request.context);
+  if (mode === "dryRun") {
+    if (effect.dryRunHandler) {
+      return { effect, mode, handler: effect.dryRunHandler };
+    }
+    if (behaviors.dryRun?.enabled) {
+      return { effect, mode, handler: effect.handler };
+    }
+    throw new Error(`Dry run is not supported for ${request.effectKey}`);
+  }
+  if (mode === "reverse") {
+    if (effect.reverseHandler) {
+      return { effect, mode, handler: effect.reverseHandler };
+    }
+    const reverseEffect = resolveReverseEffect(effectMap, effect, request, behaviors);
+    if (reverseEffect) {
+      return {
+        effect: reverseEffect,
+        mode,
+        handler: reverseEffect.reverseHandler || reverseEffect.handler
+      };
+    }
+    throw new Error(`Reverse execution is not supported for ${request.effectKey}`);
+  }
+  return { effect, mode, handler: effect.handler };
+}
+async function invokeRegisteredEffect(effectMap, request) {
+  const effect = effectMap.get(request.effectKey);
+  if (!effect) {
+    throw new Error(`Effect handler not found: ${request.effectKey}`);
+  }
+  const resolved = resolveHandlerForMode(effectMap, effect, request);
+  const context = {
+    ...request.context || {},
+    behaviors: normalizeEffectBehaviors(request.context?.behaviors || effect.metamodels || void 0),
+    invocation: {
+      mode: resolved.mode,
+      sourceEffectKey: request.effectKey,
+      sourceEffectName: request.effectName,
+      ...request.context?.invocation?.reverseHandler ? { reverseHandler: request.context.invocation.reverseHandler } : {}
+    }
+  };
+  if (resolved.effect.className && !resolved.effect.static && request.input && typeof request.input === "object" && "_objectId" in request.input) {
+    const { _objectId, ...rest } = request.input;
+    return resolved.handler(_objectId, rest, context);
+  }
+  return resolved.handler(request.input, context);
+}
+function buildFieldMetamodelMutations(fieldPath, spec) {
+  return metamodelPresetDefault.DEFAULT_METAMODEL_PACKAGES.flatMap(
+    (pkg) => pkg.manifest?.buildFieldMutations?.(fieldPath, spec) || []
+  );
+}
+function buildModelMetamodelMutations(modelPath, spec) {
+  return metamodelPresetDefault.DEFAULT_METAMODEL_PACKAGES.flatMap(
+    (pkg) => pkg.manifest?.buildModelMutations?.(modelPath, spec) || []
+  );
+}
+function buildEffectMetamodelMutations(toolPath, spec) {
+  if (!spec) return [];
+  return metamodelPresetDefault.DEFAULT_METAMODEL_PACKAGES.flatMap(
+    (pkg) => pkg.manifest?.buildEffectMutations?.(toolPath, spec) || []
+  );
+}
 
 // src/client.ts
 var STANDARD_MODULES_OPERATIONS = [
@@ -5387,7 +5539,7 @@ var STANDARD_MODULES_OPERATIONS = [
 var BUILTIN_MODULES = {
   "standard_modules": STANDARD_MODULES_OPERATIONS
 };
-function computeEffectKey(effect) {
+function computeEffectKey2(effect) {
   const attachedClass = effect.className?.trim();
   if (!attachedClass) {
     return `global:${effect.name}`;
@@ -5964,6 +6116,87 @@ var Environment = class extends Session {
     }
     return ref;
   }
+  async _runGraphql(query, label) {
+    const result = await this.graphql(query);
+    if (result.errors?.length) {
+      throw new Error(`${label}: ${result.errors[0].message}`);
+    }
+    return result.data;
+  }
+  async _applyFieldMetamodels(fieldPath, spec) {
+    for (const mutation of buildFieldMetamodelMutations(fieldPath, spec)) {
+      await this._runGraphql(mutation.query, mutation.label);
+    }
+  }
+  async _applyModelMetamodels(modelPath, op) {
+    for (const mutation of buildModelMetamodelMutations(modelPath, op)) {
+      await this._runGraphql(mutation.query, mutation.label);
+    }
+  }
+  async _ensureWorkspaceToolsRoot() {
+    await this._runGraphql(
+      `mutation { create_model(path: "workspace", label: "workspace") { model { path } } }`,
+      "ensure workspace"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    await this._runGraphql(
+      `mutation { at(path: "workspace") { create_submodel(subpath: "tools", label: "Tools") { model { path } } } }`,
+      "ensure workspace:tools"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    await this._runGraphql(
+      `mutation { at(path: "workspace:tools") { create_submodel(subpath: "declared", label: "Declared") { model { path } } } }`,
+      "ensure workspace:tools:declared"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+  }
+  async _storeEffectSchemas(toolPath, effect) {
+    await this._runGraphql(
+      `mutation { at(path: ${JSON.stringify(toolPath)}) { create_submodel(subpath: "inputSchema", label: "inputSchema") { set_string_value(value: ${JSON.stringify(JSON.stringify(effect.inputSchema))}) { done } } } }`,
+      `store inputSchema on ${toolPath}`
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    if (effect.outputSchema) {
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(toolPath)}) { create_submodel(subpath: "outputSchema", label: "outputSchema") { set_string_value(value: ${JSON.stringify(JSON.stringify(effect.outputSchema))}) { done } } } }`,
+        `store outputSchema on ${toolPath}`
+      ).catch((error) => {
+        if (!error.message.includes("already exists")) throw error;
+      });
+    }
+  }
+  async _applyEffectMetamodels(toolPath, metamodels) {
+    for (const mutation of buildEffectMetamodelMutations(toolPath, metamodels)) {
+      await this._runGraphql(mutation.query, mutation.label);
+    }
+  }
+  async _applyEffectDeclaration(effect, aliasMap) {
+    let containerPath = "workspace:tools:declared";
+    if (effect.attachedClass) {
+      containerPath = this._resolveAlias(effect.attachedClass, aliasMap);
+    } else {
+      await this._ensureWorkspaceToolsRoot();
+    }
+    await this._runGraphql(
+      `mutation { at(path: ${JSON.stringify(containerPath)}) { create_submodel(subpath: ${JSON.stringify(effect.name)}, label: ${JSON.stringify(effect.name)}) { model { path } } } }`,
+      `create effect model ${containerPath}:${effect.name}`
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    const toolPath = `${containerPath}:${effect.name}`;
+    if (effect.description) {
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(toolPath)}) { set_description(description: ${JSON.stringify(effect.description)}) { done } } }`,
+        `set effect description on ${toolPath}`
+      );
+    }
+    await this._storeEffectSchemas(toolPath, effect);
+    await this._applyEffectMetamodels(toolPath, effect.metamodels);
+  }
   /**
    * Apply a single manifest operation via GraphQL
    */
@@ -5986,24 +6219,32 @@ var Environment = class extends Session {
       const extendsRef = op.extends ? this._resolveAlias(op.extends, aliasMap) : void 0;
       const instanceOfRef = op.instanceOf ? this._resolveAlias(op.instanceOf, aliasMap) : void 0;
       if (extendsRef) {
-        await this.graphql(
-          `mutation { create_model(path: "${op.create}", label: "${label}") { model { path } } }`
+        await this._runGraphql(
+          `mutation { create_model(path: "${op.create}", label: "${label}") { model { path } } }`,
+          `create model ${op.create}`
         );
-        await this.graphql(
-          `mutation { at(path: "${op.create}") { add_superclass(superclass: "${extendsRef}") { model { path } } } }`
+        await this._runGraphql(
+          `mutation { at(path: "${op.create}") { add_superclass(superclass: "${extendsRef}") { model { path } } } }`,
+          `add superclass ${extendsRef} to ${op.create}`
         );
       } else if (instanceOfRef) {
-        await this.graphql(
-          `mutation { at(path: "${instanceOfRef}") { instantiate(path: "${op.create}", label: "${label}") { model { path } } } }`
+        await this._runGraphql(
+          `mutation { at(path: "${instanceOfRef}") { instantiate(path: "${op.create}", label: "${label}") { model { path } } } }`,
+          `instantiate ${op.create} from ${instanceOfRef}`
         );
       } else {
-        await this.graphql(
-          `mutation { create_model(path: "${op.create}", label: "${label}") { model { path } } }`
+        await this._runGraphql(
+          `mutation { create_model(path: "${op.create}", label: "${label}") { model { path } } }`,
+          `create model ${op.create}`
         );
       }
       if (op.has) {
         await this._applyFields(op.create, op.has);
       }
+      await this._applyModelMetamodels(op.create, op);
+      if (op.withEffect) {
+        await this._applyEffectDeclaration(op.withEffect, aliasMap);
+      }
       return;
     }
     if (op.on) {
@@ -6011,8 +6252,15 @@ var Environment = class extends Session {
       if (op.has) {
         await this._applyFields(target, op.has);
       }
+      await this._applyModelMetamodels(target, op);
+      if (op.withEffect) {
+        await this._applyEffectDeclaration(op.withEffect, aliasMap);
+      }
       return;
     }
+    if (op.withEffect) {
+      await this._applyEffectDeclaration(op.withEffect, aliasMap);
+    }
   }
   /**
    * Apply field definitions (has) to a model via GraphQL
@@ -6020,81 +6268,91 @@ var Environment = class extends Session {
   async _applyFields(modelPath, fields) {
     for (const [fieldName, spec] of Object.entries(fields)) {
       const fieldLabel = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
-      await this.graphql(
+      await this._runGraphql(
         `mutation {
-                    at(path: "${modelPath}") {
-                        create_submodel(subpath: "${fieldName}", label: "${fieldLabel}") {
+                    at(path: ${JSON.stringify(modelPath)}) {
+                        create_submodel(subpath: ${JSON.stringify(fieldName)}, label: ${JSON.stringify(fieldLabel)}) {
                             model { path }
                         }
                     }
-                }`
-      );
+                }`,
+        `create field ${modelPath}.${fieldName}`
+      ).catch((error) => {
+        if (!error.message.includes("already exists")) throw error;
+      });
       if (spec.type) {
-        await this.graphql(
+        await this._runGraphql(
           `mutation {
-                        at(path: "${modelPath}") {
-                            at(submodel: "${fieldName}") {
-                                add_prototype(prototype: "${spec.type}") { done }
+                        at(path: ${JSON.stringify(modelPath)}) {
+                            at(submodel: ${JSON.stringify(fieldName)}) {
+                                add_prototype(prototype: ${JSON.stringify(spec.type)}) { done }
                             }
                         }
-                    }`
+                    }`,
+          `set prototype on ${modelPath}:${fieldName}`
         );
       }
       if (spec.description) {
-        await this.graphql(
+        await this._runGraphql(
           `mutation {
-                        at(path: "${modelPath}") {
-                            at(submodel: "${fieldName}") {
-                                set_description(description: "${spec.description}") { done }
+                        at(path: ${JSON.stringify(modelPath)}) {
+                            at(submodel: ${JSON.stringify(fieldName)}) {
+                                set_description(description: ${JSON.stringify(spec.description)}) { done }
                             }
                         }
-                    }`
+                    }`,
+          `set description on ${modelPath}:${fieldName}`
         );
       }
       if (spec.value !== void 0 && spec.value !== null) {
         if (typeof spec.value === "string") {
-          await this.graphql(
+          await this._runGraphql(
             `mutation {
-                            at(path: "${modelPath}") {
-                                at(submodel: "${fieldName}") {
-                                    set_string_value(value: "${spec.value}") { done }
+                            at(path: ${JSON.stringify(modelPath)}) {
+                                at(submodel: ${JSON.stringify(fieldName)}) {
+                                    set_string_value(value: ${JSON.stringify(spec.value)}) { done }
                                 }
                             }
-                        }`
+                        }`,
+            `set string value on ${modelPath}:${fieldName}`
           );
         } else if (typeof spec.value === "number") {
-          await this.graphql(
+          await this._runGraphql(
             `mutation {
-                            at(path: "${modelPath}") {
-                                at(submodel: "${fieldName}") {
+                            at(path: ${JSON.stringify(modelPath)}) {
+                                at(submodel: ${JSON.stringify(fieldName)}) {
                                     set_number_value(value: ${spec.value}) { done }
                                 }
                             }
-                        }`
+                        }`,
+            `set number value on ${modelPath}:${fieldName}`
           );
         } else if (typeof spec.value === "boolean") {
-          await this.graphql(
+          await this._runGraphql(
             `mutation {
-                            at(path: "${modelPath}") {
-                                at(submodel: "${fieldName}") {
+                            at(path: ${JSON.stringify(modelPath)}) {
+                                at(submodel: ${JSON.stringify(fieldName)}) {
                                     set_boolean_value(value: ${spec.value}) { done }
                                 }
                             }
-                        }`
+                        }`,
+            `set boolean value on ${modelPath}:${fieldName}`
           );
         }
       }
       if (spec.ref) {
-        await this.graphql(
+        await this._runGraphql(
           `mutation {
-                        at(path: "${modelPath}") {
-                            at(submodel: "${fieldName}") {
-                                set_reference(reference: "${spec.ref}") { done }
+                        at(path: ${JSON.stringify(modelPath)}) {
+                            at(submodel: ${JSON.stringify(fieldName)}) {
+                                set_reference(reference: ${JSON.stringify(spec.ref)}) { done }
                             }
                         }
-                    }`
+                    }`,
+          `set reference on ${modelPath}:${fieldName}`
         );
       }
+      await this._applyFieldMetamodels(`${modelPath}:${fieldName}`, spec);
       if (spec.has) {
         await this._applyFields(`${modelPath}:${fieldName}`, spec.has);
       }
@@ -6434,7 +6692,7 @@ var Granular = class {
   }
   serializeEffect(effect) {
     return {
-      effectKey: computeEffectKey(effect),
+      effectKey: computeEffectKey2(effect),
       name: effect.name,
       description: effect.description,
       inputSchema: effect.inputSchema,
@@ -6470,23 +6728,54 @@ var Granular = class {
     const host = await this.ensureSandboxEffectHost(sandboxId);
     await this.publishSandboxEffectCatalog(host);
   }
-  startEffectHostHeartbeat(host) {
-    if (host.heartbeatTimer) {
-      clearInterval(host.heartbeatTimer);
+  recoverEffectHost(host, error) {
+    if (host.recovering) {
+      return;
+    }
+    if (this.sandboxEffectHosts.get(host.sandboxId) !== host) {
+      return;
     }
-    host.wsClient.call("client.heartbeat", {}).catch((error) => {
+    host.recovering = true;
+    this.stopEffectHostHeartbeat(host);
+    this.sandboxEffectHosts.delete(host.sandboxId);
+    try {
+      host.wsClient.disconnect();
+    } catch (disconnectError) {
       console.warn(
-        `[Granular] Initial effect host heartbeat failed for sandbox ${host.sandboxId}:`,
-        error
+        `[Granular] Failed to disconnect stale effect host for sandbox ${host.sandboxId}:`,
+        disconnectError
+      );
+    }
+    void this.ensureSandboxEffectHost(host.sandboxId).catch((reconnectError) => {
+      console.error(
+        `[Granular] Failed to recover effect host for sandbox ${host.sandboxId} after heartbeat failure:`,
+        reconnectError
       );
+      console.error("[Granular] Original heartbeat failure:", error);
     });
-    host.heartbeatTimer = setInterval(() => {
+  }
+  startEffectHostHeartbeat(host) {
+    if (host.heartbeatTimer) {
+      clearInterval(host.heartbeatTimer);
+    }
+    host.heartbeatInFlight = false;
+    const sendHeartbeat = (failureLabel, recoverOnFailure) => {
+      if (host.heartbeatInFlight || host.recovering) {
+        return;
+      }
+      host.heartbeatInFlight = true;
       host.wsClient.call("client.heartbeat", {}).catch((error) => {
-        console.warn(
-          `[Granular] Effect host heartbeat failed for sandbox ${host.sandboxId}:`,
-          error
-        );
+        console.warn(`${failureLabel} ${host.sandboxId}:`, error);
+        if (recoverOnFailure) {
+          this.recoverEffectHost(host, error);
+        }
+      }).finally(() => {
+        host.heartbeatInFlight = false;
       });
+    };
+    sendHeartbeat("[Granular] Initial effect host heartbeat failed for sandbox", false);
+    host.heartbeatTimer = setInterval(() => {
+      sendHeartbeat("[Granular] Effect host heartbeat failed for sandbox", true);
     }, 1e4);
   }
   stopEffectHostHeartbeat(host) {
@@ -6495,6 +6784,7 @@ var Granular = class {
     }
     clearInterval(host.heartbeatTimer);
     host.heartbeatTimer = null;
+    host.heartbeatInFlight = false;
   }
   async synchronizeEffectHost(host) {
     await host.wsClient.call("client.hello", {
@@ -6530,19 +6820,13 @@ var Granular = class {
         effectClientId,
         clientId,
         wsClient,
-        heartbeatTimer: null
+        heartbeatTimer: null,
+        heartbeatInFlight: false,
+        recovering: false
       };
       wsClient.registerRpcHandler("effect.invoke", async (params) => {
         const request = params;
-        const effect = this.getSandboxEffectMap(sandboxId).get(request.effectKey);
-        if (!effect) {
-          throw new Error(`Effect handler not found: ${request.effectKey}`);
-        }
-        if (effect.className && !effect.static && request.input && typeof request.input === "object" && "_objectId" in request.input) {
-          const { _objectId, ...rest } = request.input;
-          return effect.handler(_objectId, rest, request.context);
-        }
-        return effect.handler(request.input, request.context);
+        return invokeRegisteredEffect(this.getSandboxEffectMap(sandboxId), request);
       });
       wsClient.on("open", () => {
         void this.synchronizeEffectHost(host).catch((error) => {
@@ -6585,7 +6869,7 @@ var Granular = class {
   async registerEffect(sandboxNameOrId, effect) {
     const sandbox = await this.findOrCreateSandbox(sandboxNameOrId);
     const sandboxId = sandbox.sandboxId;
-    this.getSandboxEffectMap(sandboxId).set(computeEffectKey(effect), effect);
+    this.getSandboxEffectMap(sandboxId).set(computeEffectKey2(effect), effect);
     await this.syncSandboxEffectCatalog(sandboxId);
   }
   /**
@@ -6598,7 +6882,7 @@ var Granular = class {
     const sandboxId = sandbox.sandboxId;
     const map = this.getSandboxEffectMap(sandboxId);
     for (const effect of effects) {
-      map.set(computeEffectKey(effect), effect);
+      map.set(computeEffectKey2(effect), effect);
     }
     await this.syncSandboxEffectCatalog(sandboxId);
   }
@@ -6879,5 +7163,7 @@ exports.Environment = Environment;
 exports.Granular = Granular;
 exports.Session = Session;
 exports.WSClient = WSClient;
+exports.invokeRegisteredEffect = invokeRegisteredEffect;
+exports.normalizeEffectBehaviors = normalizeEffectBehaviors;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map