@spotpatch/runtime 1.8.0 → 1.10.0

package/dist/chunk-7ES63LA7.js

@@ -0,0 +1,28 @@
+// src/ui/ui-constants.ts
+var UI_MARKER_ATTRIBUTE = "data-spotpatch-ui";
+var UI_Z_INDEX = Object.freeze({
+  highlight: 2147483646,
+  controls: 2147483647
+});
+
+// src/ui/dom.ts
+function createMarkedElement(document, tagName) {
+  const element = document.createElement(tagName);
+  element.setAttribute(UI_MARKER_ATTRIBUTE, "");
+  return element;
+}
+function createButton(document, label, className = "") {
+  const button = createMarkedElement(document, "button");
+  button.type = "button";
+  button.className = className;
+  button.textContent = label;
+  return button;
+}
+
+export {
+  UI_MARKER_ATTRIBUTE,
+  UI_Z_INDEX,
+  createMarkedElement,
+  createButton
+};
+//# sourceMappingURL=chunk-7ES63LA7.js.map

package/dist/chunk-7ES63LA7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ui/ui-constants.ts","../src/ui/dom.ts"],"sourcesContent":["export const UI_MARKER_ATTRIBUTE = \"data-spotpatch-ui\" as const;\n\nexport const UI_Z_INDEX = Object.freeze({\n  highlight: 2_147_483_646,\n  controls: 2_147_483_647,\n});\n","import { UI_MARKER_ATTRIBUTE } from \"./ui-constants.js\";\n\nexport function createMarkedElement<K extends keyof HTMLElementTagNameMap>(\n  document: Document,\n  tagName: K,\n): HTMLElementTagNameMap[K] {\n  const element = document.createElement(tagName);\n  element.setAttribute(UI_MARKER_ATTRIBUTE, \"\");\n  return element;\n}\n\nexport function createButton(\n  document: Document,\n  label: string,\n  className = \"\",\n): HTMLButtonElement {\n  const button = createMarkedElement(document, \"button\");\n  button.type = \"button\";\n  button.className = className;\n  button.textContent = label;\n  return button;\n}\n"],"mappings":";AAAO,IAAM,sBAAsB;AAE5B,IAAM,aAAa,OAAO,OAAO;AAAA,EACtC,WAAW;AAAA,EACX,UAAU;AACZ,CAAC;;;ACHM,SAAS,oBACd,UACA,SAC0B;AAC1B,QAAM,UAAU,SAAS,cAAc,OAAO;AAC9C,UAAQ,aAAa,qBAAqB,EAAE;AAC5C,SAAO;AACT;AAEO,SAAS,aACd,UACA,OACA,YAAY,IACO;AACnB,QAAM,SAAS,oBAAoB,UAAU,QAAQ;AACrD,SAAO,OAAO;AACd,SAAO,YAAY;AACnB,SAAO,cAAc;AACrB,SAAO;AACT;","names":[]}

package/dist/chunk-NII5OBAN.js

@@ -0,0 +1,14 @@
+// src/ui/data-flow-panel-contract.ts
+var DATA_FLOW_EXTENSION_KEY = /* @__PURE__ */ Symbol.for("spotpatch.data-flow.extension.v1");
+function registerDataFlowExtension(extension, target = globalThis) {
+  target[DATA_FLOW_EXTENSION_KEY] = extension;
+}
+function getDataFlowExtension(target = globalThis) {
+  return target[DATA_FLOW_EXTENSION_KEY];
+}
+
+export {
+  registerDataFlowExtension,
+  getDataFlowExtension
+};
+//# sourceMappingURL=chunk-NII5OBAN.js.map

package/dist/chunk-NII5OBAN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ui/data-flow-panel-contract.ts"],"sourcesContent":["import type {\n  ComponentDataFlowReport,\n  NetworkObservation,\n  PageDataFlowReport,\n  SpotPatchLocale,\n} from \"@spotpatch/shared\";\n\nimport type { DataFlowComponentRegistration } from \"../data-flow/data-flow-runtime.js\";\n\nexport type DataFlowPanelStatus = \"disabled\" | \"idle\" | \"loading\" | \"ready\" | \"error\";\n\nexport interface DataFlowPanelSnapshot {\n  readonly status: DataFlowPanelStatus;\n  readonly report?: ComponentDataFlowReport | PageDataFlowReport;\n  readonly message?: string;\n}\n\nexport interface DataFlowViewState {\n  readonly component: DataFlowPanelSnapshot;\n  readonly page: DataFlowPanelSnapshot;\n  readonly observationCount: number;\n}\n\nexport interface DataFlowPanel {\n  readonly root: HTMLElement;\n  readonly refreshButton: HTMLButtonElement;\n  readonly styles: HTMLStyleElement;\n  readonly dispose: () => void;\n  readonly render: (state: DataFlowViewState) => void;\n  readonly resetView: () => void;\n}\n\nexport type DataFlowPanelFactory = (\n  document: Document,\n  enabled: boolean,\n  locale: () => SpotPatchLocale,\n  changesRoot: HTMLElement,\n  diagnosticsRoot: HTMLElement,\n  onViewChange: () => void,\n) => DataFlowPanel;\n\nexport interface DataFlowExtension {\n  readonly createPanel: DataFlowPanelFactory;\n  readonly getComponentRegistration: (\n    component: object,\n  ) => DataFlowComponentRegistration | undefined;\n  readonly observations: (routeKey: string) => readonly NetworkObservation[];\n  readonly mergeComponentReport: (\n    report: ComponentDataFlowReport,\n    observations: readonly NetworkObservation[],\n  ) => ComponentDataFlowReport;\n  readonly mergePageReport: (\n    report: PageDataFlowReport,\n    observations: readonly NetworkObservation[],\n  ) => PageDataFlowReport;\n}\n\nconst DATA_FLOW_EXTENSION_KEY = Symbol.for(\"spotpatch.data-flow.extension.v1\");\ntype ExtensionStore = Partial<Record<symbol, DataFlowExtension>>;\n\nexport function registerDataFlowExtension(\n  extension: DataFlowExtension,\n  target: ExtensionStore = globalThis,\n): void {\n  target[DATA_FLOW_EXTENSION_KEY] = extension;\n}\n\nexport function getDataFlowExtension(\n  target: ExtensionStore = globalThis,\n): DataFlowExtension | undefined {\n  return target[DATA_FLOW_EXTENSION_KEY];\n}\n"],"mappings":";AAyDA,IAAM,0BAA0B,uBAAO,IAAI,kCAAkC;AAGtE,SAAS,0BACd,WACA,SAAyB,YACnB;AACN,SAAO,uBAAuB,IAAI;AACpC;AAEO,SAAS,qBACd,SAAyB,YACM;AAC/B,SAAO,OAAO,uBAAuB;AACvC;","names":[]}

package/dist/chunk-QY5T4DPA.js

@@ -0,0 +1,552 @@
+// src/data-flow/data-flow-runtime.ts
+import {
+  DATA_FLOW_SCHEMA_VERSION,
+  DATA_FLOW_URL_QUERY_KEY_LIMIT,
+  SPOTPATCH_API_BASE
+} from "@spotpatch/shared/data-flow-runtime";
+var RUNTIME_KEY = /* @__PURE__ */ Symbol.for(
+  "spotpatch.data-flow.runtime.v1"
+);
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+function positiveNow(target) {
+  return target.performance?.now() ?? Date.now();
+}
+function createOpaqueSequence(prefix) {
+  let sequence = 0;
+  const randomPrefix = (() => {
+    try {
+      const bytes = new Uint8Array(8);
+      globalThis.crypto.getRandomValues(bytes);
+      return Array.from(bytes, (value) => value.toString(36).padStart(2, "0")).join("");
+    } catch {
+      return "local";
+    }
+  })();
+  return () => {
+    sequence += 1;
+    return `${prefix}_${randomPrefix}_${sequence.toString(36)}`;
+  };
+}
+function freezeUrl(value, baseUrl) {
+  try {
+    const url = new URL(value, baseUrl);
+    return Object.freeze({
+      origin: url.origin,
+      pathname: url.pathname,
+      queryKeys: Object.freeze(
+        [...new Set(url.searchParams.keys())].sort().slice(0, DATA_FLOW_URL_QUERY_KEY_LIMIT)
+      )
+    });
+  } catch {
+    return Object.freeze({
+      pathname: value.split(/[?#]/u, 1)[0] ?? "{invalid}",
+      queryKeys: Object.freeze([])
+    });
+  }
+}
+function readFetchUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  return input.url;
+}
+function readFetchMethod(input, init) {
+  if (init?.method !== void 0) return init.method.toUpperCase();
+  return typeof Request !== "undefined" && input instanceof Request ? input.method.toUpperCase() : "GET";
+}
+function isSpotPatchInternalUrl(value, baseUrl) {
+  try {
+    const pathname = new URL(value, baseUrl).pathname;
+    return pathname === SPOTPATCH_API_BASE || pathname.startsWith(`${SPOTPATCH_API_BASE}/`);
+  } catch {
+    return false;
+  }
+}
+function approximateBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function createRingStore(limits, target) {
+  const entries = [];
+  let totalBytes = 0;
+  function removeExpired(now) {
+    while (entries[0] !== void 0 && now - entries[0].recordedAt > limits.observationTtlMs) {
+      const removed = entries.shift();
+      if (removed !== void 0) totalBytes -= removed.bytes;
+    }
+  }
+  return Object.freeze({
+    add(observation) {
+      const now = positiveNow(target);
+      removeExpired(now);
+      const bytes = approximateBytes(observation);
+      if (bytes > limits.observationMaxBytes) return;
+      entries.push(Object.freeze({ bytes, observation, recordedAt: now }));
+      totalBytes += bytes;
+      while (entries.length > limits.observationMaxEntries || totalBytes > limits.observationMaxBytes) {
+        const removed = entries.shift();
+        if (removed !== void 0) totalBytes -= removed.bytes;
+      }
+    },
+    clear() {
+      entries.length = 0;
+      totalBytes = 0;
+    },
+    values() {
+      removeExpired(positiveNow(target));
+      return Object.freeze(entries.map(({ observation }) => observation));
+    }
+  });
+}
+function ownPropertyDescriptor(target, key) {
+  try {
+    return Object.getOwnPropertyDescriptor(target, key);
+  } catch {
+    return void 0;
+  }
+}
+function nestedReactWrapperComponent(candidate) {
+  const marker = ownPropertyDescriptor(candidate, "$$typeof")?.value;
+  const key = marker === REACT_MEMO_TYPE ? "type" : marker === REACT_FORWARD_REF_TYPE ? "render" : void 0;
+  if (key === void 0) return void 0;
+  const nested = ownPropertyDescriptor(candidate, key)?.value;
+  return typeof nested === "object" && nested !== null || typeof nested === "function" ? nested : void 0;
+}
+function installWritableDataProperty(target, key, replacement, original = ownPropertyDescriptor(target, key)) {
+  if (original === void 0 || !("value" in original) || !original.writable) {
+    return void 0;
+  }
+  try {
+    Object.defineProperty(target, key, { ...original, value: replacement });
+  } catch {
+    return void 0;
+  }
+  return () => {
+    try {
+      if (ownPropertyDescriptor(target, key)?.value === replacement) {
+        Object.defineProperty(target, key, original);
+      }
+    } catch {
+    }
+  };
+}
+function recordWithoutAffectingHost(record) {
+  try {
+    record();
+  } catch {
+  }
+}
+function createDataFlowRuntime(config, target = globalThis) {
+  const componentRegistry = /* @__PURE__ */ new WeakMap();
+  const xhrMetadata = /* @__PURE__ */ new WeakMap();
+  const store = createRingStore(config.limits, target);
+  const nextInvocationId = createOpaqueSequence("invocation");
+  const nextObservationId = createOpaqueSequence("observation");
+  const pageEpoch = createOpaqueSequence("page")();
+  const nextRouteEpoch = createOpaqueSequence("route");
+  let routeEpoch = nextRouteEpoch();
+  let routeKey;
+  let currentInvocation;
+  let currentRequestFrame;
+  let disposed = false;
+  const originalFetch = (() => {
+    try {
+      return target.fetch;
+    } catch {
+      return void 0;
+    }
+  })();
+  function spotPatchFetch(input, init) {
+    if (originalFetch === void 0) {
+      throw new TypeError("Fetch is unavailable.");
+    }
+    const result = Reflect.apply(originalFetch, this, [input, init]);
+    recordWithoutAffectingHost(() => {
+      const frame = currentRequestFrame;
+      const token = frame?.invocationToken;
+      const rawUrl = readFetchUrl(input);
+      if (isSpotPatchInternalUrl(
+        rawUrl,
+        target.location?.href ?? "http://spotpatch.invalid/"
+      )) {
+        return;
+      }
+      store.add(
+        Object.freeze({
+          schemaVersion: DATA_FLOW_SCHEMA_VERSION,
+          id: nextObservationId(),
+          pageEpoch,
+          routeEpoch,
+          ...frame === void 0 ? {} : {
+            requestCallsiteId: frame.requestCallsiteId,
+            sourceVersion: frame.sourceVersion
+          },
+          ...token === void 0 ? {} : {
+            invocationId: token.invocationId,
+            componentSourceId: token.componentSourceId,
+            triggerCallsiteId: token.triggerCallsiteId
+          },
+          transport: "fetch",
+          method: readFetchMethod(input, init),
+          url: freezeUrl(rawUrl, target.location?.href ?? "http://spotpatch.invalid/"),
+          outcome: "dispatched",
+          freshness: "current",
+          diagnosticIds: Object.freeze([])
+        })
+      );
+    });
+    return result;
+  }
+  const restoreFetch = originalFetch === void 0 ? void 0 : installWritableDataProperty(target, "fetch", spotPatchFetch);
+  const xhrPrototype = (() => {
+    try {
+      return target.XMLHttpRequest?.prototype;
+    } catch {
+      return void 0;
+    }
+  })();
+  const originalOpenDescriptor = xhrPrototype === void 0 ? void 0 : ownPropertyDescriptor(xhrPrototype, "open");
+  const originalSendDescriptor = xhrPrototype === void 0 ? void 0 : ownPropertyDescriptor(xhrPrototype, "send");
+  function spotPatchOpen(method, url, ...rest) {
+    const original = originalOpenDescriptor?.value;
+    if (typeof original === "function") {
+      Reflect.apply(original, this, [method, url, ...rest]);
+    }
+    recordWithoutAffectingHost(() => {
+      xhrMetadata.set(this, Object.freeze({ method, url: String(url) }));
+    });
+  }
+  function spotPatchSend(body) {
+    const original = originalSendDescriptor?.value;
+    if (typeof original === "function") Reflect.apply(original, this, [body]);
+    recordWithoutAffectingHost(() => {
+      const metadata = xhrMetadata.get(this);
+      if (metadata === void 0 || isSpotPatchInternalUrl(
+        metadata.url,
+        target.location?.href ?? "http://spotpatch.invalid/"
+      )) {
+        return;
+      }
+      const frame = currentRequestFrame;
+      const token = frame?.invocationToken;
+      store.add(
+        Object.freeze({
+          schemaVersion: DATA_FLOW_SCHEMA_VERSION,
+          id: nextObservationId(),
+          pageEpoch,
+          routeEpoch,
+          ...frame === void 0 ? {} : {
+            requestCallsiteId: frame.requestCallsiteId,
+            sourceVersion: frame.sourceVersion
+          },
+          ...token === void 0 ? {} : {
+            invocationId: token.invocationId,
+            componentSourceId: token.componentSourceId,
+            triggerCallsiteId: token.triggerCallsiteId
+          },
+          transport: "xhr",
+          method: metadata.method.toUpperCase(),
+          url: freezeUrl(
+            metadata.url,
+            target.location?.href ?? "http://spotpatch.invalid/"
+          ),
+          outcome: "dispatched",
+          freshness: "current",
+          diagnosticIds: Object.freeze([])
+        })
+      );
+    });
+  }
+  const restoreXhrOpen = xhrPrototype === void 0 || typeof originalOpenDescriptor?.value !== "function" ? void 0 : installWritableDataProperty(
+    xhrPrototype,
+    "open",
+    spotPatchOpen,
+    originalOpenDescriptor
+  );
+  const restoreXhrSend = xhrPrototype === void 0 || typeof originalSendDescriptor?.value !== "function" ? void 0 : installWritableDataProperty(
+    xhrPrototype,
+    "send",
+    spotPatchSend,
+    originalSendDescriptor
+  );
+  const runtime = Object.freeze({
+    beginInvocation(metadata) {
+      return Object.freeze({
+        invocationId: nextInvocationId(),
+        componentSourceId: metadata.componentSourceId,
+        triggerCallsiteId: metadata.triggerCallsiteId,
+        sourceVersion: metadata.sourceVersion
+      });
+    },
+    bindInvocation(token, callback) {
+      return function boundInvocation(...args) {
+        return runtime.withInvocation(token, () => Reflect.apply(callback, this, args));
+      };
+    },
+    bindTrigger(metadata, callback) {
+      if (typeof callback !== "function") return callback;
+      const callable = callback;
+      return function boundTrigger(...args) {
+        const token = runtime.beginInvocation(metadata);
+        return runtime.withInvocation(token, () => Reflect.apply(callable, this, args));
+      };
+    },
+    captureInvocation: () => currentInvocation,
+    clear: store.clear,
+    createTrpcLink() {
+      return () => (options) => {
+        recordWithoutAffectingHost(() => {
+          const operation = options.op.path;
+          const operationType = options.op.type;
+          if (typeof operation !== "string" || operation.length === 0 || operation.length > 512 || operationType !== "query" && operationType !== "mutation" && operationType !== "subscription") {
+            return;
+          }
+          const frame = currentRequestFrame;
+          const token = frame?.invocationToken;
+          store.add(
+            Object.freeze({
+              schemaVersion: DATA_FLOW_SCHEMA_VERSION,
+              id: nextObservationId(),
+              pageEpoch,
+              routeEpoch,
+              ...frame === void 0 ? {} : {
+                requestCallsiteId: frame.requestCallsiteId,
+                sourceVersion: frame.sourceVersion
+              },
+              ...token === void 0 ? {} : {
+                invocationId: token.invocationId,
+                componentSourceId: token.componentSourceId,
+                triggerCallsiteId: token.triggerCallsiteId
+              },
+              transport: "trpc",
+              method: operationType.toUpperCase(),
+              operation,
+              url: Object.freeze({
+                pathname: operation,
+                queryKeys: Object.freeze([])
+              }),
+              outcome: "dispatched",
+              freshness: "current",
+              diagnosticIds: Object.freeze([])
+            })
+          );
+        });
+        return options.next(options.op);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      store.clear();
+      restoreFetch?.();
+      restoreXhrOpen?.();
+      restoreXhrSend?.();
+    },
+    getComponentRegistration: (component) => componentRegistry.get(component),
+    getCurrentRequestFrame: () => currentRequestFrame,
+    observations: () => Object.freeze(
+      store.values().map(
+        (observation) => observation.routeEpoch === routeEpoch ? observation : Object.freeze({ ...observation, freshness: "stale-route" })
+      )
+    ),
+    registerComponent(component, componentSourceId, registeredSourceVersion) {
+      const registration = Object.freeze({
+        componentSourceId,
+        sourceVersion: registeredSourceVersion
+      });
+      const pending = [component];
+      const registered = /* @__PURE__ */ new Set();
+      while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate === void 0 || registered.has(candidate)) continue;
+        registered.add(candidate);
+        componentRegistry.set(candidate, registration);
+        const nested = nestedReactWrapperComponent(candidate);
+        if (nested !== void 0) pending.push(nested);
+      }
+    },
+    updateRoute(nextRouteKey) {
+      if (routeKey === void 0) {
+        routeKey = nextRouteKey;
+      } else if (routeKey !== nextRouteKey) {
+        routeKey = nextRouteKey;
+        routeEpoch = nextRouteEpoch();
+      }
+    },
+    withInvocation(token, callback) {
+      const parent = currentInvocation;
+      currentInvocation = token;
+      try {
+        return callback();
+      } finally {
+        currentInvocation = parent;
+      }
+    },
+    withRequestFrame(token, metadata, callback) {
+      const parent = currentRequestFrame;
+      currentRequestFrame = Object.freeze({
+        requestCallsiteId: metadata.requestCallsiteId,
+        sourceVersion: metadata.sourceVersion,
+        ...token === void 0 ? {} : { invocationToken: token }
+      });
+      try {
+        return callback();
+      } finally {
+        currentRequestFrame = parent;
+      }
+    }
+  });
+  return runtime;
+}
+function installDataFlowPrelude(config, target = globalThis) {
+  if (!config.enabled) return void 0;
+  const runtime = target[RUNTIME_KEY] ?? createDataFlowRuntime(config, target);
+  target[RUNTIME_KEY] = runtime;
+  return runtime;
+}
+function getDataFlowRuntime(target = globalThis) {
+  return target[RUNTIME_KEY];
+}
+
+// src/data-flow/report-merger.ts
+import {
+  isSensitiveName,
+  limitDataFlowReportCollections
+} from "@spotpatch/shared";
+function observationMatchesDependency(observation, dependency) {
+  const origin = dependency.origin;
+  const transportMatches = dependency.kind === "rpc" ? observation.transport === "trpc" && dependency.operation !== void 0 && observation.operation === dependency.operation : dependency.kind === "http" ? observation.transport === "fetch" || observation.transport === "xhr" : false;
+  if (!transportMatches || observation.freshness !== "current" || origin === void 0 || observation.requestCallsiteId !== origin.requestCallsiteId || observation.sourceVersion !== origin.sourceVersion || dependency.method !== void 0 && observation.method.toUpperCase() !== dependency.method.toUpperCase() || dependency.url !== void 0 && observation.url.pathname !== dependency.url.pathname || dependency.url?.origin !== void 0 && observation.url.origin !== dependency.url.origin || origin.componentSourceId !== void 0 && observation.componentSourceId !== void 0 && observation.componentSourceId !== origin.componentSourceId || origin.triggerCallsiteId !== void 0 && observation.triggerCallsiteId !== void 0 && observation.triggerCallsiteId !== origin.triggerCallsiteId) {
+    return false;
+  }
+  return dependency.association !== "transitive" || observation.componentSourceId === origin.componentSourceId && observation.triggerCallsiteId === origin.triggerCallsiteId;
+}
+function runtimeEvidence(observation) {
+  return Object.freeze({
+    id: observation.id,
+    kind: "runtime-observation",
+    summaryKey: "dataFlow.evidence.runtimeDispatch"
+  });
+}
+function mergeDependencies(dependencies, observations) {
+  const matchedObservationIds = /* @__PURE__ */ new Set();
+  const merged = dependencies.map((dependency) => {
+    const matches = observations.filter(
+      (observation) => observationMatchesDependency(observation, dependency)
+    );
+    for (const observation of matches) matchedObservationIds.add(observation.id);
+    if (matches.length === 0) return dependency;
+    const observedOrigins = [
+      ...new Set(
+        matches.flatMap(({ url }) => url.origin === void 0 ? [] : [url.origin])
+      )
+    ];
+    const observedOrigin = observedOrigins.length === 1 ? observedOrigins[0] : void 0;
+    return Object.freeze({
+      ...dependency,
+      ...dependency.url === void 0 || dependency.url.origin !== void 0 || observedOrigin === void 0 ? {} : {
+        url: Object.freeze({
+          ...dependency.url,
+          origin: observedOrigin
+        })
+      },
+      execution: "observed",
+      observationIds: Object.freeze([
+        .../* @__PURE__ */ new Set([...dependency.observationIds, ...matches.map(({ id }) => id)])
+      ]),
+      evidenceIds: Object.freeze([
+        .../* @__PURE__ */ new Set([...dependency.evidenceIds, ...matches.map(({ id }) => id)])
+      ])
+    });
+  });
+  return Object.freeze({
+    dependencies: Object.freeze(merged),
+    matchedObservationIds
+  });
+}
+function appendRuntimeEvidence(evidence, observations, matchedIds) {
+  const existing = new Set(evidence.map(({ id }) => id));
+  return Object.freeze([
+    ...evidence,
+    ...observations.flatMap(
+      (observation) => matchedIds.has(observation.id) && !existing.has(observation.id) ? [runtimeEvidence(observation)] : []
+    )
+  ]);
+}
+function mergeComponentDataFlowReport(report, observations) {
+  const componentObservations = observations.filter(
+    (observation) => observation.componentSourceId === void 0 || observation.componentSourceId === report.component.componentSourceId
+  );
+  const merged = mergeDependencies(report.dependencies, componentObservations);
+  return limitDataFlowReportCollections(
+    Object.freeze({
+      ...report,
+      dependencies: merged.dependencies,
+      evidence: appendRuntimeEvidence(
+        report.evidence,
+        componentObservations,
+        merged.matchedObservationIds
+      )
+    }),
+    { mode: "observation" }
+  );
+}
+function unassignedDependency(observation) {
+  const isRpc = observation.transport === "trpc";
+  return Object.freeze({
+    id: observation.id,
+    kind: isRpc ? "rpc" : "http",
+    direction: observation.method === "GET" || observation.method === "HEAD" || observation.method === "QUERY" || observation.method === "SUBSCRIPTION" ? "read" : "write",
+    execution: "observed",
+    proof: "unavailable",
+    association: "unassigned",
+    method: observation.method,
+    ...isRpc ? observation.operation === void 0 ? {} : { operation: observation.operation } : { url: observation.url },
+    parameters: Object.freeze(
+      (isRpc ? [] : observation.url.queryKeys).map(
+        (path) => Object.freeze({
+          path,
+          position: "query",
+          sensitive: isSensitiveName(path),
+          valueState: "not-collected",
+          evidenceIds: Object.freeze([observation.id])
+        })
+      )
+    ),
+    response: Object.freeze({
+      consumedFields: Object.freeze([])
+    }),
+    suppliedBindings: Object.freeze([]),
+    locationIds: Object.freeze([]),
+    evidenceIds: Object.freeze([observation.id]),
+    observationIds: Object.freeze([observation.id])
+  });
+}
+function mergePageDataFlowReport(report, observations) {
+  const currentObservations = observations.filter(
+    ({ freshness }) => freshness === "current"
+  );
+  const merged = mergeDependencies(report.dependencies, currentObservations);
+  const unassigned = currentObservations.filter(({ id }) => !merged.matchedObservationIds.has(id)).map(unassignedDependency);
+  const allObservationIds = new Set(currentObservations.map(({ id }) => id));
+  return limitDataFlowReportCollections(
+    Object.freeze({
+      ...report,
+      dependencies: Object.freeze([...merged.dependencies, ...unassigned]),
+      evidence: appendRuntimeEvidence(
+        report.evidence,
+        currentObservations,
+        allObservationIds
+      )
+    }),
+    { mode: "observation" }
+  );
+}
+
+export {
+  createDataFlowRuntime,
+  installDataFlowPrelude,
+  getDataFlowRuntime,
+  mergeComponentDataFlowReport,
+  mergePageDataFlowReport
+};
+//# sourceMappingURL=chunk-QY5T4DPA.js.map