agent-inspect 6.31.31 → 6.31.33

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 6.31.33
+
+### Patch Changes
+
+- b2adf03: Fail requiredOrder when a before tool starts but never finishes while after runs (#521). Escape mixed-script lookalike tool names in tool.usage findings and sort allowlist causes first (#522).
+
+## 6.31.32
+
+### Patch Changes
+
+- d9ab3e9: Break causal ordering timestamp ties by recorded row order (#518 / #517). Detect Stripe `sk_live_`/`rk_live_`/`sk_test_` and Slack `xox…` values in redact, pre-disk free-text, and verify-safe (#520). Set `check --evidence-on` Evidence `assessment.status` from residual verify-safe, not check pass/fail (#519). Unlink starter control traces so prove-same-output-wrong-path is idempotent (#523).
+
 ## 6.31.31
 
 ### Patch Changes

package/README.md

@@ -213,7 +213,7 @@ The root package is enough for custom capture, the CLI, checks, and Evidence wor
 
 ## Status and documentation
 
-**Current published baseline:** **6.31.31** · persisted schema `1.0` · Node.js `>=20` · MIT.
+**Current published baseline:** **6.31.33** · persisted schema `1.0` · Node.js `>=20` · MIT.
 
 Legacy v0.1 and v0.2 traces remain readable. Check the npm badge and [changelog](CHANGELOG.md) for the current published version.
 

package/docs/CLI.md

@@ -349,6 +349,8 @@ Options:
 - `--evidence-profile <local|share|strict>`: redaction profile for Evidence (default `share`)
 - `--evidence-format <directory|html|zip>`: Evidence layout (default `directory`)
 
+Evidence `assessment.status` is residual `verify-safe` of the redacted artifact (same sense as `bundle`), not the trajectory check pass/fail. Check results stay in `check-results.json` / the summary text.
+
 By default, `check` runs `run.status`. Additional built-in rules can be selected with `--rule` or config when their options are available. Prefer `--preset trajectory` in CI, then `verify-safe` before sharing.
 
 Config files use either `checks` (flat rule options) or top-level `contract`
@@ -1097,7 +1099,7 @@ Options:
 - `--format <format>` — `markdown`, `json`, `json-compact`, `html`, `junit`, `github`, or `github-annotations` (default: `markdown`)
 - `-o, --output <dir>` — write `gate-results.json`, `gate-summary.md`, `gate-report.html`, `junit.xml`, `github-step-summary.md`, `github-annotations.txt`
 - `--json` — print deterministic JSON result (pretty); use `--format json-compact` for CI logs
-- `--evidence-on <fail|always|never>` — write local Evidence v2 (no upload); omitted = never
+- `--evidence-on <fail|always|never>` — write local Evidence v2 (no upload); omitted = never. `assessment.status` is residual verify-safe of the redacted artifact, not gate pass/fail.
 - `--evidence-dir <path>` — Evidence output directory or base path
 - `--evidence-profile <local|share|strict>` — redaction profile (default `share`)
 - `--evidence-format <directory|html|zip>` — Evidence layout (default `directory`)

package/docs/TRACE-CONTRACTS.md

@@ -44,6 +44,8 @@ Contracts compile to deterministic check rules for common cases:
 - `happens-before` requires the first `before` occurrence to finish before the first `after` occurrence starts;
 - `all-occurrences` requires every `before` occurrence to finish before every `after` occurrence starts (`max(before.end) <= min(after.start)`);
 - causal modes fail when a required interval boundary cannot be resolved instead of falling back to encounter order.
+- when the boundary timestamps tie at millisecond resolution (for example scripted or mocked tools that start and finish inside one millisecond), causal modes decide by recorded event order: the before event must have been recorded as finished before the after event was recorded as started. Such findings carry `resolvedBy: "recorded-order"`.
+- a `before` tool that starts but never finishes (`status: "running"`) while a later `after` tool finishes fails the order rule in every mode with `tool.order.interval-unresolved` (unfinished before), naming the abandoned tool — not only the generic incomplete-running `run.status` finding.
 
 Examples for `requiredOrder: ["retrieve_policy", "send_email"]` (both TOOL-typed):
 
@@ -118,6 +120,8 @@ The evaluator expands each list into adjacent pairs and applies one `requiredOrd
 - `requiredOrderMode: "happens-before"` requires the first before to **end** before the first after **starts**; overlap fails.
 - `requiredOrderMode: "all-occurrences"` requires every before to end before every after starts; any cross-boundary overlap or later before fails.
 - Missing interval boundaries fail closed in the two causal modes.
+- Millisecond timestamp ties are decided by recorded event order in the two causal modes.
+- A started-but-never-finished `before` tool (running, no completion) fails order in every mode when `after` has finished, with `tool.order.interval-unresolved`.
 
 ### `alternatives.anyOf` (shipped)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-inspect",
-  "version": "6.31.31",
+  "version": "6.31.33",
   "license": "MIT",
   "type": "module",
   "description": "Local evidence debugger and trajectory-test toolkit for TypeScript AI agents — execution trees, TraceContract checks, Evidence v2, and read-only MCP",

package/packages/cli/dist/{chunk-4GTOJ3G2.mjs → chunk-AILSHDEF.mjs}

@@ -937,6 +937,10 @@ var HIGH_CONFIDENCE_CREDENTIAL_PATTERNS = [
   /\b[a-z0-9_.-]+=[^;\s]+(?:;\s*[a-z0-9_.-]+=[^;\s]+)+/i,
   /\beyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\b/,
   /\b(?:sk-(?:proj-)?[a-zA-Z0-9_-]{16,}|sk-ant-[a-zA-Z0-9_-]{16,}|AIza[0-9A-Za-z_-]{20,})\b/,
+  // Stripe secret / restricted keys use underscores (not sk-). Keep in sync with
+  // packages/redact/src/index.ts + packages/core/src/checks DEFAULT_SECRET_PATTERNS (#520).
+  /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/,
+  /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/,
   /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/,
   /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
   /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/,
@@ -7047,10 +7051,17 @@ function contractToRules(contract) {
             (event) => event.status === "running"
           );
           if (running.length > 0) {
+            const labels = running.map((event) => {
+              if (event.kind === "TOOL") {
+                return `tool ${resolveCanonicalToolName(event)}`;
+              }
+              return `${event.kind} ${event.name}`;
+            });
+            const message = labels.length === 1 ? `Run contains incomplete running events: ${labels[0]} never completed.` : `Run contains incomplete running events: ${labels.join("; ")}.`;
             findings.push(
               contractFailFinding(
                 "contract.run.allowedStatuses",
-                "Run contains incomplete running events.",
+                message,
                 running.map((event) => ({
                   runId: event.runId,
                   eventId: event.eventId,
@@ -7059,7 +7070,10 @@ function contractToRules(contract) {
                   status: event.status
                 })),
                 "no running events",
-                running.length
+                {
+                  count: running.length,
+                  unfinished: labels
+                }
               )
             );
           }
@@ -7818,6 +7832,12 @@ var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
 var DEFAULT_SECRET_PATTERNS = [
   { id: "bearer-token", pattern: /Bearer\s+[A-Za-z0-9._~+/-]{12,}=*/ },
   { id: "openai-key", pattern: /sk-[A-Za-z0-9_-]{16,}/ },
+  // Stripe + Slack: keep in sync with packages/redact + credential-value-patterns (#520).
+  {
+    id: "stripe-key",
+    pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/
+  },
+  { id: "slack-token", pattern: /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/ },
   { id: "aws-access-key", pattern: /AKIA[0-9A-Z]{16}/ },
   { id: "github-token", pattern: /gh[opsu]_[A-Za-z0-9_]{20,}/ },
   // Keep in sync with packages/redact/src/key-value-secret.ts (KEY_VALUE_SECRET_PATTERN_SOURCE).
@@ -7999,6 +8019,11 @@ function compareFindings(eventById) {
     if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
       return STATUS_RANK[a.status] - STATUS_RANK[b.status];
     }
+    if (a.ruleId === "tool.usage") {
+      const aHasEvent = a.evidence[0]?.eventId !== void 0;
+      const bHasEvent = b.evidence[0]?.eventId !== void 0;
+      if (aHasEvent !== bHasEvent) return aHasEvent ? -1 : 1;
+    }
     const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
     if (byRun !== 0) return byRun;
     const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
@@ -8124,6 +8149,37 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
 function toolName(event) {
   return resolveCanonicalToolName(event);
 }
+function formatToolNameForMessage(name) {
+  const details = [];
+  for (let index = 0; index < name.length; ) {
+    const codePoint = name.codePointAt(index);
+    const width = codePoint > 65535 ? 2 : 1;
+    if (codePoint > 127) {
+      details.push(
+        `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")} at index ${index}`
+      );
+    }
+    index += width;
+  }
+  if (details.length === 0) return name;
+  return `"${name}" (contains ${details.join("; ")})`;
+}
+function describeRunningEvent(event) {
+  if (event.kind === "TOOL") {
+    return `tool ${formatToolNameForMessage(resolveCanonicalToolName(event))}`;
+  }
+  if (event.kind === "LLM") {
+    return `llm ${stepEndpointName(event, "LLM")}`;
+  }
+  return `${event.kind} ${event.name}`;
+}
+function incompleteRunningMessage(prefix, running) {
+  const labels = running.map(describeRunningEvent);
+  if (labels.length === 1) {
+    return `${prefix}: ${labels[0]} never completed.`;
+  }
+  return `${prefix}: ${labels.join("; ")}.`;
+}
 function stepEndpointName(event, kind) {
   if (kind === "TOOL") return resolveCanonicalToolName(event);
   for (const prefix of ["llm:", "generation:", "transcription:", "speech:"]) {
@@ -8198,6 +8254,56 @@ function eventEndMs(event) {
   }
   return void 0;
 }
+function rowIndexByEventId(events) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [position, event] of events.entries()) {
+    if (!index.has(event.eventId)) index.set(event.eventId, position);
+  }
+  return index;
+}
+function recordedRowSpan(rowIndex, event) {
+  const sourceIds = "sourceEventIds" in event && Array.isArray(event.sourceEventIds) ? event.sourceEventIds : [event.eventId];
+  const rows = [];
+  for (const id of sourceIds) {
+    const row = typeof id === "string" ? rowIndex.get(id) : void 0;
+    if (row === void 0) return void 0;
+    rows.push(row);
+  }
+  if (rows.length === 0) return void 0;
+  return { first: Math.min(...rows), last: Math.max(...rows) };
+}
+function recordedTieOrder(context, tiedBefore, tiedAfter) {
+  const rowIndex = rowIndexByEventId(context.events);
+  let lastFinished;
+  let firstStarted;
+  for (const event of tiedBefore) {
+    const span = recordedRowSpan(rowIndex, event);
+    if (span === void 0) return { inOrder: void 0 };
+    if (lastFinished === void 0 || span.last > lastFinished.row) {
+      lastFinished = { event, row: span.last };
+    }
+  }
+  for (const event of tiedAfter) {
+    const span = recordedRowSpan(rowIndex, event);
+    if (span === void 0) return { inOrder: void 0 };
+    if (firstStarted === void 0 || span.first < firstStarted.row) {
+      firstStarted = { event, row: span.first };
+    }
+  }
+  if (lastFinished === void 0 || firstStarted === void 0) return { inOrder: void 0 };
+  return {
+    inOrder: lastFinished.row < firstStarted.row,
+    lastFinishedBefore: lastFinished.event,
+    firstStartedAfter: firstStarted.event
+  };
+}
+function tieResolution(order) {
+  return order.inOrder === void 0 ? "recorded-order-unavailable" : "recorded-order";
+}
+function tieMessage(order, beforeLabel, afterLabel) {
+  if (order === void 0 || order.inOrder === true) return "";
+  return order.inOrder === void 0 ? " Their timestamps tie at the same millisecond and the recorded event order could not be resolved." : ` Their timestamps tie at the same millisecond; the recorded event order shows ${afterLabel} started before ${beforeLabel} finished.`;
+}
 function normalizedKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]/g, "");
 }
@@ -8415,10 +8521,13 @@ function createRunStatusRule(options = {}) {
           findings.push(
             failFinding(
               "run.status",
-              "Run contains incomplete running events.",
+              incompleteRunningMessage("Run contains incomplete running events", running),
               running.map((event) => eventEvidence3(event)),
               "no running events",
-              running.length
+              {
+                count: running.length,
+                unfinished: running.map(describeRunningEvent)
+              }
             )
           );
         }
@@ -8588,6 +8697,34 @@ function createToolUsageRule(options) {
       const names = tools.map(toolName);
       const nameSet = new Set(names);
       const findings = [];
+      const forbidden = new Set(options.forbidden ?? []);
+      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
+      for (const event of tools) {
+        const name = toolName(event);
+        const display = formatToolNameForMessage(name);
+        if (forbidden.has(name)) {
+          findings.push(
+            failFinding(
+              "tool.usage",
+              `Forbidden tool ${display} appeared.`,
+              [eventEvidence3(event)],
+              "tool absent",
+              name
+            )
+          );
+        }
+        if (allowed && !allowed.has(name)) {
+          findings.push(
+            failFinding(
+              "tool.usage",
+              `Tool ${display} is not in the allowed tool set.`,
+              [eventEvidence3(event)],
+              [...allowed].sort(),
+              name
+            )
+          );
+        }
+      }
       for (const required of options.required ?? []) {
         if (!nameSet.has(required)) {
           const otherKinds = [
@@ -8605,7 +8742,7 @@ function createToolUsageRule(options) {
           findings.push(
             failFinding(
               "tool.usage",
-              `Required tool ${required} did not appear.${hint}`,
+              `Required tool ${formatToolNameForMessage(required)} did not appear.${hint}`,
               runEvidence(context.selectedRun),
               required,
               names
@@ -8613,21 +8750,6 @@ function createToolUsageRule(options) {
           );
         }
       }
-      const forbidden = new Set(options.forbidden ?? []);
-      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
-      for (const event of tools) {
-        const name = toolName(event);
-        if (forbidden.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence3(event)], "tool absent", name)
-          );
-        }
-        if (allowed && !allowed.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence3(event)], [...allowed].sort(), name)
-          );
-        }
-      }
       if (options.minCount !== void 0 && tools.length < options.minCount) {
         findings.push(
           failFinding("tool.usage", `Tool count ${tools.length} was below minimum ${options.minCount}.`, runEvidence(context.selectedRun), { minCount: options.minCount }, tools.length)
@@ -8661,6 +8783,28 @@ function createStepOrderingRule(options) {
       const afterEvents = finishedEvents(context, options.after.kind).filter(
         (event) => stepEndpointName(event, options.after.kind) === options.after.name
       );
+      const beforeRunning = semanticEvents(context).filter(
+        (event) => event.kind === options.before.kind && event.status === "running" && stepEndpointName(event, options.before.kind) === options.before.name
+      );
+      if (beforeEvents.length === 0 && afterEvents.length > 0 && beforeRunning.length > 0) {
+        const endpointExpected2 = bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after };
+        return [
+          failFinding(
+            ruleId,
+            `${subject} ${beforeLabel} started but never finished before ${afterLabel} ran.`,
+            [
+              ...beforeRunning.map((event) => eventEvidence3(event)),
+              eventEvidence3(afterEvents[0])
+            ],
+            { ...endpointExpected2, mode },
+            {
+              code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
+              unfinishedBefore: true,
+              beforeStatus: "running"
+            }
+          )
+        ];
+      }
       if (beforeEvents.length === 0 || afterEvents.length === 0) {
         if (!requireEndpoints) return [];
         const findings = [];
@@ -8777,16 +8921,18 @@ function createStepOrderingRule(options) {
             )
           ];
         }
-        if (beforeEnd > afterStart) {
+        const tie = beforeEnd === afterStart ? recordedTieOrder(context, [beforeEvent], [afterEvent]) : void 0;
+        if (beforeEnd > afterStart || tie !== void 0 && tie.inOrder !== true) {
           return [
             failFinding(
               ruleId,
-              `${subject} ${beforeLabel} must finish before ${afterLabel} starts.`,
+              `${subject} ${beforeLabel} must finish before ${afterLabel} starts.${tieMessage(tie, beforeLabel, afterLabel)}`,
               [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
                 beforeEndedAt: new Date(beforeEnd).toISOString(),
-                afterStartedAt: new Date(afterStart).toISOString()
+                afterStartedAt: new Date(afterStart).toISOString(),
+                ...tie !== void 0 ? { resolvedBy: tieResolution(tie) } : {}
               }
             )
           ];
@@ -8849,16 +8995,27 @@ function createStepOrderingRule(options) {
             )
           ];
         }
-        if (latestBefore.end > earliestAfter.start) {
+        const tiedEnd = latestBefore.end;
+        const tiedStart = earliestAfter.start;
+        const tie = tiedEnd === tiedStart ? recordedTieOrder(
+          context,
+          beforeEvents.filter((event) => eventEndMs(event) === tiedEnd),
+          afterEvents.filter((event) => eventStartMs(event) === tiedStart)
+        ) : void 0;
+        if (latestBefore.end > earliestAfter.start || tie !== void 0 && tie.inOrder !== true) {
           return [
             failFinding(
               ruleId,
-              bothTools ? `Every ${options.before.name} tool call must finish before any ${options.after.name} tool call starts.` : `Every ${beforeLabel} must finish before any ${afterLabel} starts.`,
-              [eventEvidence3(latestBefore.event), eventEvidence3(earliestAfter.event)],
+              (bothTools ? `Every ${options.before.name} tool call must finish before any ${options.after.name} tool call starts.` : `Every ${beforeLabel} must finish before any ${afterLabel} starts.`) + tieMessage(tie, beforeLabel, afterLabel),
+              [
+                eventEvidence3(tie?.lastFinishedBefore ?? latestBefore.event),
+                eventEvidence3(tie?.firstStartedAfter ?? earliestAfter.event)
+              ],
               expected,
               {
                 latestBeforeEndedAt: new Date(latestBefore.end).toISOString(),
-                earliestAfterStartedAt: new Date(earliestAfter.start).toISOString()
+                earliestAfterStartedAt: new Date(earliestAfter.start).toISOString(),
+                ...tie !== void 0 ? { resolvedBy: tieResolution(tie) } : {}
               }
             )
           ];
@@ -9024,10 +9181,13 @@ function createStructureIncompleteRule(options = {}) {
           findings.push(
             failFinding(
               "structure.incomplete",
-              "Trace contains incomplete running events.",
+              incompleteRunningMessage("Trace contains incomplete running events", running),
               running.map((event) => eventEvidence3(event, "status")),
               "no running events",
-              running.length
+              {
+                count: running.length,
+                unfinished: running.map(describeRunningEvent)
+              }
             )
           );
         }
@@ -16011,5 +16171,5 @@ function renderGateReport(result, options = {}) {
 }
 
 export { ATTRIBUTION_CONFIDENCES, COHORT_METRIC_IDS, DEFAULT_REDACT_KEYS, DEFAULT_SUITE_ARTIFACTS_DIR, DELIVERY_CONFLICT_ATTR, DELIVERY_EVENT_BASE_ATTR, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, IDENTITY_CONFLICT_ATTR, Redactor, TraceDirectory, TraceReadError, TreeBuilder, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, applyProfileMetadataCaps, assertBundlePathContained, assertEvidenceRelativePath, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildEvidenceCausalFailureViewHtml, buildEvidenceCiPackage, buildEvidenceCircuitViewHtml, buildEvidenceContractsViewHtml, buildEvidenceDiffViewHtml, buildEvidenceHtmlShell, buildEvidenceManifest, buildEvidenceOutcomesViewHtml, buildEvidenceProvenanceViewHtml, buildEvidenceSafetyViewHtml, buildEvidenceTimelineViewHtml, buildEvidenceToolsLlmViewHtml, buildEvidenceTreeViewHtml, buildLocalExplanation, buildPlaceholderArtifact, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, buildZipArchive, bundleFailsOnSafety, bundleRunAssetRelativePath, collectTraceSchemaVersions, compactAttributes, createBaselineRegressionRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRunDepthRule, createRunDurationRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolUsageRule, defaultBundleOutputPath, defaultSuiteConfigTemplate, defineTraceContract, diffRuns, diffTraceEvents, enrichSessionRunRecord, escapeHtml, escapeMarkdown, evaluateTraceContract, extractMetadata, extractOutcomesFromTraceEvents, filterMetasBySessionScope, filterTraces, flattenTree, formatDuration2 as formatDuration, formatStepLabel, formatTimestamp, gateHasThresholds, getIndent, getTraceFilePath, inferEvidenceFileRole, isAgentInspectTrace, isAttributionConfidence, isCredentialSensitiveKey, isPersistedInspectEvent, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, manualTraceEventsToComparableRun, nanoid, normalizeBundleOutputPath, openTrace, parseCohortMetricList, parseDuration, parseDurationFilter, parseGateList, parseTraceJsonl, persistedInspectEventsToRunTrees, persistedInspectEventsToTraceEvents, projectLogicalEvents, renderActivitySummaryHuman, renderCohortReport, renderErrorLine, renderGateReport, renderObservedOutcomesHtml, renderObservedOutcomesMarkdown, renderRunDiff, renderRunWhat, renderStepLine, renderSuiteReport, renderTimeline, renderTraceStats, resolveBundleRunIds, resolveRedactionProfile, resolveSuiteTemplate, resolveTraceDir, runGate, runSuite, runTraceChecks, safeString, sanitizeBundleRunId, searchTraces, serializeEvidenceManifest, sha256Hex, stableJson, stringContainsHighConfidenceCredential, summarizeObservedOutcomes, summarizeSemanticParity, traceEventToPersistedInspectEvent, truncateName, truncateStringForProfile, validateEvent, validateSuiteConfig, verifyEvidenceDirectory, zeroKinds };
-//# sourceMappingURL=chunk-4GTOJ3G2.mjs.map
-//# sourceMappingURL=chunk-4GTOJ3G2.mjs.map
+//# sourceMappingURL=chunk-AILSHDEF.mjs.map
+//# sourceMappingURL=chunk-AILSHDEF.mjs.map