@mermanjs/node 0.8.0-alpha.5 → 0.8.0-alpha.7

package/dist/engine.mjs

@@ -4,6 +4,7 @@ import {
   NODE_TRANSPORT_FIELD_LIMITS,
   NODE_TRANSPORT_LIMITS,
   NODE_WIRE_CONTRACT,
+  abortError,
   assertUtf8Field,
   decodeWireInvocationError,
   decodeWireResponse,
@@ -28,7 +29,7 @@ import {
   TEXT_MEASUREMENT_PROTOCOL_VERSION,
   TEXT_MEASUREMENT_PROVIDER_IDS,
   TEXT_MEASUREMENT_PROVIDER_SPECS,
-  VENDORED_TEXT_MEASUREMENT_PROVIDER_ID,
+  DETERMINISTIC_TEXT_MEASUREMENT_PROVIDER_ID,
 } from "./generated/binding-contract.mjs";
 
 const RESOURCE_PROFILES = new Set([
@@ -86,6 +87,7 @@ const COMPILED_PREREQUISITES_BY_OPERATION_ID = new Map(
 const KNOWN_OUTPUT_CONTRACT_BY_ID = new Map(
   NODE_WIRE_CONTRACT.artifact.output_contracts.map((contract) => [contract.id, contract]),
 );
+const MAX_OPERATION_TIMEOUT_MS = 0xffff_ffff;
 const MERMAN_ENGINE_CONSTRUCTION_TOKEN = Symbol("MermanEngine construction");
 
 export async function createNodeEngine(
@@ -144,6 +146,19 @@ export function normalizeBindingOptions(value = {}) {
   if (!RESOURCE_PROFILES.has(normalized.resources.profile)) {
     throw new RangeError(`Unknown resource profile \`${normalized.resources.profile}\`.`);
   }
+  if (normalized.environment !== undefined) {
+    if (!isPlainObject(normalized.environment)) {
+      throw new TypeError("bindingOptions.environment must be a plain object.");
+    }
+    if (
+      normalized.environment.text_measurement !== undefined &&
+      normalized.environment.text_measurement !== "deterministic"
+    ) {
+      throw new RangeError(
+        "bindingOptions.environment.text_measurement must be `deterministic`.",
+      );
+    }
+  }
   return normalized;
 }
 
@@ -181,31 +196,37 @@ export class MermanEngine {
   renderSvg(source, options = {}) {
     return this.executeOperation(
       { operationId: "svg", source, optionsJson: options.optionsJson },
-      { signal: options.signal },
+      { signal: options.signal, timeoutMs: options.timeoutMs },
     ).then((result) => result.data);
   }
 
   renderSvgSync(source, options = {}) {
-    return this.executeOperationSync({
-      operationId: "svg",
-      source,
-      optionsJson: options.optionsJson,
-    }).data;
+    return this.executeOperationSync(
+      {
+        operationId: "svg",
+        source,
+        optionsJson: options.optionsJson,
+      },
+      { timeoutMs: options.timeoutMs },
+    ).data;
   }
 
   svgPlanJson(source, options = {}) {
     return this.executeOperation(
       { operationId: "svg-plan-json", source, optionsJson: options.optionsJson },
-      { signal: options.signal },
+      { signal: options.signal, timeoutMs: options.timeoutMs },
     ).then((result) => result.data);
   }
 
   svgPlanJsonSync(source, options = {}) {
-    return this.executeOperationSync({
-      operationId: "svg-plan-json",
-      source,
-      optionsJson: options.optionsJson,
-    }).data;
+    return this.executeOperationSync(
+      {
+        operationId: "svg-plan-json",
+        source,
+        optionsJson: options.optionsJson,
+      },
+      { timeoutMs: options.timeoutMs },
+    ).data;
   }
 
   metadataJson(id) {
@@ -232,17 +253,33 @@ export class MermanEngine {
     return value;
   }
 
-  executeOperation(request, { signal } = {}) {
-    const encoded = operationRequestJson(request);
+  executeOperation(request, { signal, timeoutMs } = {}) {
+    try {
+      this.#executor.assertOpen();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const prepared = prepareOperationRequest(request, { timeoutMs });
+    if (signal?.aborted) return Promise.reject(abortError());
+    const encoded = operationRequestJson(prepared);
     return this.#executor.submit(
       async () => {
+        // A signal can flip after queue admission but before this start microtask runs. That work
+        // has not crossed the transport boundary, so preserve the established AbortError result.
+        if (signal?.aborted) throw abortError();
         let responseJson;
         try {
-          responseJson = await this.#transport.execute(encoded.json);
+          responseJson = await executeTransportOperation(
+            this.#transport,
+            encoded.json,
+            signal,
+            timeoutMs,
+          );
         } catch (cause) {
           throw decodeWireInvocationError(cause, "Merman operation");
         }
         return decodeWireResponse(responseJson, encoded.expectation, {
+          allowedCancellationReasons: invocationCancellationReasons(signal, timeoutMs),
           requireUnavailable: !this.#operationIds.has(encoded.expectation.operation_id),
         });
       },
@@ -250,16 +287,17 @@ export class MermanEngine {
     );
   }
 
-  executeOperationSync(request) {
+  executeOperationSync(request, { timeoutMs } = {}) {
     this.#executor.assertSyncAvailable();
-    const encoded = operationRequestJson(request);
+    const encoded = operationRequestJson(prepareOperationRequest(request, { timeoutMs }));
     let responseJson;
     try {
-      responseJson = this.#transport.executeSync(encoded.json);
+      responseJson = this.#transport.executeSync(encoded.json, timeoutMs);
     } catch (cause) {
       throw decodeWireInvocationError(cause, "Merman operation");
     }
     return decodeWireResponse(responseJson, encoded.expectation, {
+      allowedCancellationReasons: invocationCancellationReasons(undefined, timeoutMs),
       requireUnavailable: !this.#operationIds.has(encoded.expectation.operation_id),
     });
   }
@@ -273,7 +311,14 @@ export class MermanEngine {
   }
 }
 
-function operationRequestJson(value) {
+function invocationCancellationReasons(signal, timeoutMs) {
+  const reasons = [];
+  if (signal?.aborted) reasons.push("requested");
+  if (timeoutMs !== undefined) reasons.push("deadline_exceeded");
+  return reasons;
+}
+
+function prepareOperationRequest(value, { timeoutMs } = {}) {
   if (!isPlainObject(value)) throw new TypeError("operation request must be a plain object.");
   const knownFields = new Set(["operationId", "source", "uri", "optionsJson"]);
   for (const field of Object.keys(value)) {
@@ -281,12 +326,9 @@ function operationRequestJson(value) {
       throw new TypeError(`unknown operation request field \`${field}\`.`);
     }
   }
-  const {
-    operationId,
-    source,
-    uri = null,
-    optionsJson = undefined,
-  } = value;
+  const operationId = value.operationId;
+  const source = value.source;
+  const uri = value.uri === undefined ? null : value.uri;
   if (typeof operationId !== "string" || operationId.length === 0) {
     throw new TypeError("operationId must be a non-empty string.");
   }
@@ -327,6 +369,23 @@ function operationRequestJson(value) {
     source,
     uri: normalizedUri,
   };
+  if (timeoutMs !== undefined) {
+    if (
+      !Number.isSafeInteger(timeoutMs) ||
+      timeoutMs < 0 ||
+      timeoutMs > MAX_OPERATION_TIMEOUT_MS
+    ) {
+      throw new RangeError(
+        `operation timeoutMs must be an integer from 0 through ${MAX_OPERATION_TIMEOUT_MS}.`,
+      );
+    }
+    request.operation_control = { timeout_ms: timeoutMs };
+  }
+  return { expectation, request, value };
+}
+
+function operationRequestJson({ expectation, request, value }) {
+  const optionsJson = value.optionsJson;
   if (optionsJson !== undefined) {
     if (typeof optionsJson !== "string") {
       throw new TypeError("optionsJson must be a JSON string when provided.");
@@ -349,6 +408,32 @@ function operationRequestJson(value) {
   };
 }
 
+async function executeTransportOperation(transport, requestJson, signal, timeoutMs) {
+  if (!signal) return transport.execute(requestJson, undefined, timeoutMs);
+
+  // Forward into a private signal so the N-API bridge cannot replace a caller-owned `onabort`
+  // handler while it installs its cooperative cancellation callback.
+  const transportAbort = new AbortController();
+  let transportReady = false;
+  let pendingAbort = false;
+  const forwardAbort = () => {
+    if (transportReady) {
+      transportAbort.abort(signal.reason);
+    } else {
+      pendingAbort = true;
+    }
+  };
+  signal.addEventListener("abort", forwardAbort, { once: true });
+  try {
+    const operation = transport.execute(requestJson, transportAbort.signal, timeoutMs);
+    transportReady = true;
+    if (pendingAbort || signal.aborted) transportAbort.abort(signal.reason);
+    return await operation;
+  } finally {
+    signal.removeEventListener("abort", forwardAbort);
+  }
+}
+
 function assertTransport(transport) {
   if (
     !transport ||
@@ -893,7 +978,7 @@ function validateTextMeasurement(value, { requiresSvgPipeline }) {
     providerIds.some(
       (id) =>
         KNOWN_TEXT_MEASUREMENT_PROVIDER_IDS.has(id) &&
-        id !== VENDORED_TEXT_MEASUREMENT_PROVIDER_ID,
+        id !== DETERMINISTIC_TEXT_MEASUREMENT_PROVIDER_ID,
     )
   ) {
     throw new MermanInvalidTransportError(
@@ -902,10 +987,10 @@ function validateTextMeasurement(value, { requiresSvgPipeline }) {
   }
   if (
     requiresSvgPipeline &&
-    !providerIds.includes(VENDORED_TEXT_MEASUREMENT_PROVIDER_ID)
+    !providerIds.includes(DETERMINISTIC_TEXT_MEASUREMENT_PROVIDER_ID)
   ) {
     throw new MermanInvalidTransportError(
-      "Merman runtime catalog must expose the callable vendored text measurement provider for the SVG pipeline.",
+      "Merman runtime catalog must expose the callable deterministic text measurement provider for the SVG pipeline.",
     );
   }
   return providerIds;
@@ -914,7 +999,12 @@ function validateTextMeasurement(value, { requiresSvgPipeline }) {
 function validateRegistry(value) {
   if (
     !safeInteger(value.diagram_family_count) ||
-    value.diagram_family_count < 0
+    value.diagram_family_count < 0 ||
+    !Array.isArray(value.diagram_families) ||
+    value.diagram_families.some((family, index) =>
+      typeof family !== "string" || !/^[a-z][A-Za-z0-9]*$/.test(family) ||
+      family === "error" || (index > 0 && value.diagram_families[index - 1] >= family)
+    )
   ) {
     throw new MermanInvalidTransportError(
       "Merman runtime catalog has invalid registry metadata.",

package/dist/errors.mjs

@@ -29,7 +29,10 @@ const BINDING_STATUS_NAME_BY_CODE = new Map([
   [9, "MERMAN_INTERNAL_ERROR"],
   [10, "MERMAN_RESOURCE_LIMIT_EXCEEDED"],
   [11, "MERMAN_BUSY"],
+  [12, "MERMAN_CANCELLED"],
 ]);
+const CANCELLATION_REASONS = new Set(["requested", "deadline_exceeded"]);
+const OPERATION_PHASE_IDENTIFIER = /^[a-z][a-z0-9_-]{0,63}$/;
 const JSON_NUMBER_TOKEN = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
 const JSON_NUMBER_PARTS = /^-?(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?)(\d+))?$/;
 const MAX_SAFE_INTEGER_DECIMAL = String(RUNTIME_CATALOG_MAX_SAFE_INTEGER);
@@ -67,6 +70,10 @@ const RESPONSE_EXACT_SAFE_INTEGER_PATHS = Object.freeze([
   ["error", "code"],
   ["error", "details", "resource", "actual"],
   ["error", "details", "resource", "max"],
+  ["error", "details", "diagnostic", "span", "start"],
+  ["error", "details", "diagnostic", "span", "end"],
+  ["error", "details", "diagnostic", "requested_max_width"],
+  ["error", "details", "diagnostic", "actual_width"],
   ["error", "details", "icon_registry", "pack_index"],
 ]);
 const OPERATION_METADATA_EXACT_SAFE_INTEGER_PATHS = Object.freeze([
@@ -96,6 +103,8 @@ export class MermanOperationError extends MermanError {
     this.kind = payload.kind ?? "generic";
     this.capabilityId = payload.capability_id ?? null;
     this.resourceDetails = payload.details?.resource ?? null;
+    this.diagnosticDetails = payload.details?.diagnostic ?? null;
+    this.cancellationDetails = payload.details?.cancellation ?? null;
   }
 }
 
@@ -143,6 +152,17 @@ export class MermanMissingPlatformPackageError extends MermanError {
   }
 }
 
+export class MermanNativeLoadError extends MermanError {
+  constructor({ packageName, target, cause }) {
+    super(
+      `The installed Merman platform package ${packageName} could not load its native addon for ${target}. This is a native ABI or shared-library loader failure, not a missing npm package. Use a compatible glibc baseline or opt into @mermanjs/node-wasm.`,
+      { code: "MERMAN_NATIVE_LOAD_ERROR", cause },
+    );
+    this.packageName = packageName;
+    this.target = target;
+  }
+}
+
 export class MermanInvalidTransportError extends MermanError {
   constructor(message, cause) {
     super(message, { code: "MERMAN_INVALID_TRANSPORT", cause });
@@ -843,8 +863,9 @@ export function abortError() {
 export function decodeWireResponse(
   value,
   expectation,
-  { requireUnavailable = false } = {},
+  { allowedCancellationReasons = [], requireUnavailable = false } = {},
 ) {
+  const cancellationReasons = validateAllowedCancellationReasons(allowedCancellationReasons);
   const envelope = parseTransportJsonText(
     value,
     "response",
@@ -863,7 +884,12 @@ export function decodeWireResponse(
         "Merman transport error envelopes must contain error only.",
       );
     }
-    const error = validateErrorPayload(envelope.error, expectation, requireUnavailable);
+    const error = validateErrorPayload(
+      envelope.error,
+      expectation,
+      requireUnavailable,
+      cancellationReasons,
+    );
     throw new MermanOperationError(error);
   }
   if (envelope.ok !== true || Object.hasOwn(envelope, "error")) {
@@ -879,6 +905,16 @@ export function decodeWireResponse(
   return validateSuccessResult(envelope.result, expectation);
 }
 
+function validateAllowedCancellationReasons(reasons) {
+  if (
+    !Array.isArray(reasons) ||
+    reasons.some((reason) => !CANCELLATION_REASONS.has(reason))
+  ) {
+    throw new TypeError("allowedCancellationReasons must contain known cancellation reasons.");
+  }
+  return new Set(reasons);
+}
+
 export function decodeWireCreationError(cause, label) {
   return decodeWireFailure(cause, `${label} failed to initialize.`);
 }
@@ -990,7 +1026,12 @@ function validateSuccessResult(result, expectation) {
   return result;
 }
 
-function validateErrorPayload(error, expectation = null, requireUnavailable = false) {
+function validateErrorPayload(
+  error,
+  expectation = null,
+  requireUnavailable = false,
+  allowedCancellationReasons = new Set(),
+) {
   if (
     !isPlainJsonObject(error) ||
     !Number.isSafeInteger(error.code) ||
@@ -1029,9 +1070,18 @@ function validateErrorPayload(error, expectation = null, requireUnavailable = fa
     );
   }
   validateKnownErrorRelations(error);
-  validateResourceDetails(error.details);
+  validateErrorDetails(error.details);
 
-  if (requireUnavailable && expectation?.unavailable) {
+  if (
+    error.code === 12 &&
+    !allowedCancellationReasons.has(error.details.cancellation.reason)
+  ) {
+    throw new MermanInvalidTransportError(
+      "Merman transport returned cancellation without a matching invocation control.",
+    );
+  }
+
+  if (requireUnavailable && expectation?.unavailable && error.code !== 12) {
     const unavailable = expectation.unavailable;
     if (
       error.code !== unavailable.status_code ||
@@ -1105,9 +1155,29 @@ function validateKnownErrorRelations(error) {
   } else {
     throw new MermanInvalidTransportError("Merman transport returned an unknown error kind.");
   }
+  const cancellation = error.details?.cancellation;
+  if (error.code === 12) {
+    if (
+      error.kind !== "generic" ||
+      error.capability_id !== null ||
+      !isPlainJsonObject(error.details) ||
+      cancellation === undefined ||
+      error.details.resource !== undefined ||
+      error.details.diagnostic !== undefined ||
+      error.details.icon_registry !== undefined
+    ) {
+      throw new MermanInvalidTransportError(
+        "Merman transport returned an inconsistent cancellation error.",
+      );
+    }
+  } else if (cancellation !== undefined) {
+    throw new MermanInvalidTransportError(
+      "Merman transport attached cancellation details to a non-cancellation error.",
+    );
+  }
 }
 
-function validateResourceDetails(details) {
+function validateErrorDetails(details) {
   if (details === undefined) return;
   if (!isPlainJsonObject(details)) {
     throw new MermanInvalidTransportError("Merman transport error details must be an object.");
@@ -1132,6 +1202,49 @@ function validateResourceDetails(details) {
       );
     }
   }
+  if (details.diagnostic !== undefined) {
+    const diagnostic = details.diagnostic;
+    const span = diagnostic?.span;
+    if (
+      !isPlainJsonObject(diagnostic) ||
+      typeof diagnostic.code !== "string" ||
+      diagnostic.code.length === 0 ||
+      (diagnostic.field !== null && typeof diagnostic.field !== "string") ||
+      (diagnostic.diagram_type !== null && typeof diagnostic.diagram_type !== "string") ||
+      !isOptionalDiagnosticUnsignedInteger(diagnostic.requested_max_width) ||
+      !isOptionalDiagnosticUnsignedInteger(diagnostic.actual_width) ||
+      (diagnostic.width_profile !== undefined &&
+        diagnostic.width_profile !== null &&
+        typeof diagnostic.width_profile !== "string") ||
+      (diagnostic.fallback_reason !== undefined &&
+        diagnostic.fallback_reason !== null &&
+        typeof diagnostic.fallback_reason !== "string") ||
+      (span !== null &&
+        (!isPlainJsonObject(span) ||
+          !Number.isSafeInteger(span.start) ||
+          span.start < 0 ||
+          !Number.isSafeInteger(span.end) ||
+          span.end < span.start ||
+          !["exact", "insertion-point", "fallback"].includes(span.kind)))
+    ) {
+      throw new MermanInvalidTransportError(
+        "Merman transport returned invalid diagnostic error details.",
+      );
+    }
+  }
+  if (details.cancellation !== undefined) {
+    const cancellation = details.cancellation;
+    if (
+      !isPlainJsonObject(cancellation) ||
+      !CANCELLATION_REASONS.has(cancellation.reason) ||
+      typeof cancellation.phase !== "string" ||
+      !OPERATION_PHASE_IDENTIFIER.test(cancellation.phase)
+    ) {
+      throw new MermanInvalidTransportError(
+        "Merman transport returned invalid cancellation error details.",
+      );
+    }
+  }
   if (details.icon_registry !== undefined) {
     const iconRegistry = details.icon_registry;
     if (
@@ -1161,6 +1274,12 @@ function isBindingResourceCount(value) {
     compareCanonicalUnsignedDecimals(value, U64_MAX_DECIMAL) <= 0;
 }
 
+function isOptionalDiagnosticUnsignedInteger(value) {
+  return value === undefined ||
+    value === null ||
+    (Number.isSafeInteger(value) && value >= 0);
+}
+
 function compareCanonicalUnsignedDecimals(left, right) {
   if (left.length !== right.length) return left.length < right.length ? -1 : 1;
   if (left === right) return 0;

package/dist/generated/binding-contract.mjs

@@ -68,6 +68,14 @@ export const CAPABILITY_SPECS = [
     "id": "png",
     "implication_ids": []
   },
+  {
+    "id": "rustdoc",
+    "implication_ids": [
+      "layout-cytoscape",
+      "markdown",
+      "math"
+    ]
+  },
   {
     "id": "shell-completions",
     "implication_ids": []
@@ -142,6 +150,158 @@ export const BINDING_OPERATION_METADATA_CONTRACT = {
     }
   ],
   "output_plans": [
+    {
+      "kind": "ascii",
+      "fields": [
+        {
+          "name": "kind",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "schema_version",
+          "json_type": "unsigned-integer",
+          "required": true,
+          "integer_width_bits": 16,
+          "open_value": false
+        },
+        {
+          "name": "family",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": true
+        },
+        {
+          "name": "projection",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "encoding",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "primary_width",
+          "json_type": "unsigned-integer",
+          "required": true,
+          "integer_width_bits": 64,
+          "open_value": false
+        },
+        {
+          "name": "primary_height",
+          "json_type": "unsigned-integer",
+          "required": true,
+          "integer_width_bits": 64,
+          "open_value": false
+        },
+        {
+          "name": "emitted_width",
+          "json_type": "unsigned-integer",
+          "required": true,
+          "integer_width_bits": 64,
+          "open_value": false
+        },
+        {
+          "name": "emitted_height",
+          "json_type": "unsigned-integer",
+          "required": true,
+          "integer_width_bits": 64,
+          "open_value": false
+        },
+        {
+          "name": "width_profile",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "layout_profile",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "requested_layout_profile",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "compact_attempted",
+          "json_type": "boolean",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "requested_max_width",
+          "json_type": "unsigned-integer",
+          "required": false,
+          "integer_width_bits": 64,
+          "open_value": false
+        },
+        {
+          "name": "overflowed",
+          "json_type": "boolean",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "outcome",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "fallback_capability",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "fallback_attempted",
+          "json_type": "boolean",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "fallback_reason",
+          "json_type": "string",
+          "required": false,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "trimmed",
+          "json_type": "boolean",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        },
+        {
+          "name": "lossiness",
+          "json_type": "string",
+          "required": true,
+          "integer_width_bits": null,
+          "open_value": false
+        }
+      ]
+    },
     {
       "kind": "raster",
       "fields": [
@@ -611,23 +771,23 @@ export const BINDING_OPTION_GROUP_SPECS = [
 ];
 
 export const TEXT_MEASUREMENT_PROVIDER_SPECS = [
+  {
+    "id": "deterministic",
+    "source": "svg-pipeline",
+    "constructor_service_id": null
+  },
   {
     "id": "host-callback",
     "source": "constructor-service",
     "constructor_service_id": "host-text-measurement"
-  },
-  {
-    "id": "vendored",
-    "source": "svg-pipeline",
-    "constructor_service_id": null
   }
 ];
 
 export const TEXT_MEASUREMENT_PROVIDER_IDS = [
-  "host-callback",
-  "vendored"
+  "deterministic",
+  "host-callback"
 ];
-export const VENDORED_TEXT_MEASUREMENT_PROVIDER_ID = "vendored";
+export const DETERMINISTIC_TEXT_MEASUREMENT_PROVIDER_ID = "deterministic";
 export const HOST_CALLBACK_TEXT_MEASUREMENT_PROVIDER_ID = "host-callback";
 
 export const CONSTRUCTOR_SERVICE_SPECS = [