@rasputin-ai/browser 0.6.2 → 0.7.1

package/dist/vite/index.js

@@ -81,7 +81,7 @@ var runtimeFunctionId = (definition) => {
   return `rf_${createHash("sha256").update(identity).digest("base64url").slice(0, 24)}`;
 };
 
-// ../node_modules/.bun/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+// ../../node_modules/.bun/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -252,7 +252,7 @@ function encode(decoded) {
   return writer.flush();
 }
 
-// ../node_modules/.bun/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+// ../../node_modules/.bun/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
 var schemeRegex = /^[\w+.-]+:\/\//;
 var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
 var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
@@ -421,7 +421,7 @@ function resolve2(input, base) {
   }
 }
 
-// ../node_modules/.bun/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+// ../../node_modules/.bun/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
 function stripFilename(path) {
   if (!path) return "";
   const index = path.lastIndexOf("/");
@@ -651,6 +651,20 @@ var onInt = tagListener(() => {
   handleSignal("SIGINT");
 });
 
+// ../core/src/transport/encode-json-request-body.ts
+import { gzipSync } from "node:zlib";
+var GZIP_JSON_THRESHOLD_BYTES = 10 * 1024;
+var encodeJsonRequestBody = (payload, gzipThresholdBytes = GZIP_JSON_THRESHOLD_BYTES) => {
+  const json = JSON.stringify(payload);
+  if (Buffer.byteLength(json, "utf8") < gzipThresholdBytes) {
+    return { body: json, gzip: false };
+  }
+  const compressed = gzipSync(json);
+  const body = new Uint8Array(compressed.byteLength);
+  body.set(compressed);
+  return { body, gzip: true };
+};
+
 // ../core/src/transport/create-transport.ts
 var DEFAULTS = {
   enabled: true,
@@ -666,6 +680,11 @@ var DEFAULTS = {
   shutdownFlushMs: 2e3
 };
 
+// ../core/src/create-client/error-observation.ts
+var runtimeStateUnavailable = Symbol.for(
+  "rasputin.runtime-state.unavailable"
+);
+
 // ../core/src/derivation/sensitive-property-name.ts
 var DEFAULT_SENSITIVE_PROPERTY_NAMES = [
   "password",
@@ -849,7 +868,7 @@ var encodeFunctionPlan = (source) => {
 var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
 
 // ../instrumentation/src/classify-function.ts
-import ts4 from "typescript";
+import ts3 from "typescript";
 
 // ../instrumentation/src/collect-instrumentation-delta.ts
 import ts from "typescript";
@@ -1045,81 +1064,6 @@ var peel = (expression) => {
   return current;
 };
 
-// ../instrumentation/src/svelte-generated.ts
-import ts3 from "typescript";
-var SVELTE_TEMPLATE_FACTORIES = /* @__PURE__ */ new Set(["from_html", "from_svg", "template"]);
-var SVELTE_PROP_GETTERS = /* @__PURE__ */ new Set(["prop", "prop_source"]);
-var isFunctionLike = (node) => ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node) || ts3.isArrowFunction(node) || ts3.isMethodDeclaration(node) || ts3.isGetAccessorDeclaration(node) || ts3.isSetAccessorDeclaration(node);
-var isDescendant = (root, node) => {
-  let current = node;
-  while (current) {
-    if (current === root) return true;
-    current = current.parent;
-  }
-  return false;
-};
-var svelteCallMethod = (call) => {
-  const callee = call.expression;
-  if (!ts3.isPropertyAccessExpression(callee) || !ts3.isIdentifier(callee.expression)) {
-    return void 0;
-  }
-  if (callee.expression.text !== "$" || !ts3.isIdentifier(callee.name)) return void 0;
-  return callee.name.text;
-};
-var svelteRuntimeMethod = (node) => {
-  const parent = node.parent;
-  if (!parent || !ts3.isCallExpression(parent)) return void 0;
-  if (!parent.arguments.some((argument) => argument === node)) return void 0;
-  return svelteCallMethod(parent);
-};
-var enclosingSvelteRuntimeMethod = (node) => {
-  const direct = svelteRuntimeMethod(node);
-  if (direct) return direct;
-  let current = node;
-  let parent = node.parent;
-  while (parent) {
-    if (isFunctionLike(parent) && parent.body) {
-      if (current === parent.body || isDescendant(parent.body, current)) return void 0;
-    }
-    if (ts3.isCallExpression(parent)) {
-      const method = svelteCallMethod(parent);
-      if (method && parent.arguments.some((argument) => argument === current || isDescendant(argument, current))) {
-        return method;
-      }
-    }
-    current = parent;
-    parent = parent.parent;
-  }
-  return void 0;
-};
-var svelteGeneratedIdentifierCallees = (sourceFile) => {
-  const names = /* @__PURE__ */ new Set();
-  const visit = (node) => {
-    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer && ts3.isCallExpression(node.initializer)) {
-      const method = svelteCallMethod(node.initializer);
-      if (method && (SVELTE_TEMPLATE_FACTORIES.has(method) || SVELTE_PROP_GETTERS.has(method))) {
-        names.add(node.name.text);
-      }
-    }
-    ts3.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return names;
-};
-var isSvelteCompilerCall = (call, sourceFile, identifierCallees) => {
-  if (svelteCallMethod(call)) return true;
-  if (!ts3.isCallExpression(call) || !ts3.isIdentifier(call.expression)) return false;
-  if (call.expression.text.startsWith("$$")) return true;
-  const names = identifierCallees ?? svelteGeneratedIdentifierCallees(sourceFile);
-  return names.has(call.expression.text);
-};
-
-// ../instrumentation/src/svelte-module-path.ts
-var isSvelteCompiledPath = (idOrPath) => {
-  const path = idOrPath.split("?")[0]?.replaceAll("\\", "/") ?? "";
-  return path.endsWith(".svelte") || path.endsWith(".svelte.ts") || path.endsWith(".svelte.js");
-};
-
 // ../instrumentation/src/classify-function.ts
 var ALLOWED_STATIC_CALLS = /* @__PURE__ */ new Map([
   ["Array", /* @__PURE__ */ new Set(["isArray"])],
@@ -1128,54 +1072,54 @@ var ALLOWED_STATIC_CALLS = /* @__PURE__ */ new Map([
   ["Object", /* @__PURE__ */ new Set(["is"])]
 ]);
 var functionName = (node, sourceFile) => {
-  if (ts4.isConstructorDeclaration(node)) return "constructor";
+  if (ts3.isConstructorDeclaration(node)) return "constructor";
   if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
   const parent = node.parent;
-  if (ts4.isVariableDeclaration(parent) && ts4.isIdentifier(parent.name)) return parent.name.text;
-  if (ts4.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
-  if (ts4.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  if (ts3.isVariableDeclaration(parent) && ts3.isIdentifier(parent.name)) return parent.name.text;
+  if (ts3.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts3.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
   const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
   return `anonymous@${location.line + 1}:${location.character + 1}`;
 };
 var functionLocationPosition = (node, sourceFile) => {
   if (node.name) return node.name.getStart(sourceFile);
   const parent = node.parent;
-  if ((ts4.isVariableDeclaration(parent) || ts4.isPropertyAssignment(parent)) && parent.name) {
+  if ((ts3.isVariableDeclaration(parent) || ts3.isPropertyAssignment(parent)) && parent.name) {
     return parent.name.getStart(sourceFile);
   }
   return node.getStart(sourceFile);
 };
 var isSupportedFunction = (node) => {
-  if (!ts4.isFunctionDeclaration(node) && !ts4.isFunctionExpression(node) && !ts4.isArrowFunction(node) && !ts4.isMethodDeclaration(node) && !ts4.isGetAccessorDeclaration(node) && !ts4.isSetAccessorDeclaration(node)) {
+  if (!ts3.isFunctionDeclaration(node) && !ts3.isFunctionExpression(node) && !ts3.isArrowFunction(node) && !ts3.isMethodDeclaration(node) && !ts3.isGetAccessorDeclaration(node) && !ts3.isSetAccessorDeclaration(node)) {
     return false;
   }
   if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
   return true;
 };
 var singleReturnedExpression = (body) => {
-  if (!ts4.isBlock(body)) return body;
+  if (!ts3.isBlock(body)) return body;
   if (body.statements.length === 0) return void 0;
   if (body.statements.length !== 1) return void 0;
   const statement = body.statements[0];
-  if (!statement || !ts4.isReturnStatement(statement)) return void 0;
+  if (!statement || !ts3.isReturnStatement(statement)) return void 0;
   return statement.expression;
 };
 var isLiteralExpression = (expression) => {
   const node = peel(expression);
-  if (ts4.isStringLiteral(node) || ts4.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts4.isNumericLiteral(node)) return true;
-  if (node.kind === ts4.SyntaxKind.TrueKeyword || node.kind === ts4.SyntaxKind.FalseKeyword || node.kind === ts4.SyntaxKind.NullKeyword) {
+  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts3.isNumericLiteral(node)) return true;
+  if (node.kind === ts3.SyntaxKind.TrueKeyword || node.kind === ts3.SyntaxKind.FalseKeyword || node.kind === ts3.SyntaxKind.NullKeyword) {
     return true;
   }
-  if (ts4.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
+  if (ts3.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
   return false;
 };
 var isLiteralOnlyBody = (body) => {
-  if (ts4.isBlock(body)) {
+  if (ts3.isBlock(body)) {
     if (body.statements.length === 0) return true;
     if (body.statements.length !== 1) return false;
     const statement = body.statements[0];
-    if (!statement || !ts4.isReturnStatement(statement)) return false;
+    if (!statement || !ts3.isReturnStatement(statement)) return false;
     return !statement.expression || isLiteralExpression(statement.expression);
   }
   return isLiteralExpression(body);
@@ -1183,8 +1127,8 @@ var isLiteralOnlyBody = (body) => {
 var identifierParams = (node) => {
   const names = [];
   for (const parameter of node.parameters) {
-    if (ts4.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
-    if (!ts4.isIdentifier(parameter.name) || parameter.dotDotDotToken) return [];
+    if (ts3.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (!ts3.isIdentifier(parameter.name) || parameter.dotDotDotToken) return [];
     names.push(parameter.name.text);
   }
   return names;
@@ -1195,42 +1139,42 @@ var isIdentityFunction = (node) => {
   const returned = singleReturnedExpression(node.body);
   if (!returned) return false;
   const value = peel(returned);
-  return ts4.isIdentifier(value) && value.text === params[0];
+  return ts3.isIdentifier(value) && value.text === params[0];
 };
 var isAllowedTypeCall = (expression) => {
   const callee = peel(expression);
-  if (ts4.isIdentifier(callee)) {
+  if (ts3.isIdentifier(callee)) {
     return callee.text === "Boolean";
   }
-  if (!ts4.isPropertyAccessExpression(callee) || !ts4.isIdentifier(callee.expression)) return false;
+  if (!ts3.isPropertyAccessExpression(callee) || !ts3.isIdentifier(callee.expression)) return false;
   const allowed = ALLOWED_STATIC_CALLS.get(callee.expression.text);
-  return !!allowed && ts4.isIdentifier(callee.name) && allowed.has(callee.name.text);
+  return !!allowed && ts3.isIdentifier(callee.name) && allowed.has(callee.name.text);
 };
 var isPredicateAtom = (expression) => {
   const node = peel(expression);
-  if (isLiteralExpression(node) || ts4.isIdentifier(node)) return true;
-  if (node.kind === ts4.SyntaxKind.ThisKeyword) return true;
-  if (ts4.isPropertyAccessExpression(node)) return isPredicateAtom(node.expression);
-  if (ts4.isElementAccessExpression(node)) {
+  if (isLiteralExpression(node) || ts3.isIdentifier(node)) return true;
+  if (node.kind === ts3.SyntaxKind.ThisKeyword) return true;
+  if (ts3.isPropertyAccessExpression(node)) return isPredicateAtom(node.expression);
+  if (ts3.isElementAccessExpression(node)) {
     return isPredicateAtom(node.expression) && isPredicateAtom(node.argumentExpression);
   }
   return false;
 };
 var isPredicateExpression = (expression) => {
   const node = peel(expression);
-  if (ts4.isTypeOfExpression(node)) return isPredicateAtom(node.expression);
-  if (ts4.isPrefixUnaryExpression(node) && node.operator === ts4.SyntaxKind.ExclamationToken) {
+  if (ts3.isTypeOfExpression(node)) return isPredicateAtom(node.expression);
+  if (ts3.isPrefixUnaryExpression(node) && node.operator === ts3.SyntaxKind.ExclamationToken) {
     return isPredicateExpression(node.operand) || isPredicateAtom(node.operand);
   }
-  if (ts4.isBinaryExpression(node)) {
+  if (ts3.isBinaryExpression(node)) {
     const kind = node.operatorToken.kind;
-    if (kind === ts4.SyntaxKind.EqualsEqualsEqualsToken || kind === ts4.SyntaxKind.ExclamationEqualsEqualsToken || kind === ts4.SyntaxKind.EqualsEqualsToken || kind === ts4.SyntaxKind.ExclamationEqualsToken || kind === ts4.SyntaxKind.LessThanToken || kind === ts4.SyntaxKind.GreaterThanToken || kind === ts4.SyntaxKind.LessThanEqualsToken || kind === ts4.SyntaxKind.GreaterThanEqualsToken || kind === ts4.SyntaxKind.AmpersandAmpersandToken || kind === ts4.SyntaxKind.BarBarToken || kind === ts4.SyntaxKind.QuestionQuestionToken || kind === ts4.SyntaxKind.InstanceOfKeyword) {
+    if (kind === ts3.SyntaxKind.EqualsEqualsEqualsToken || kind === ts3.SyntaxKind.ExclamationEqualsEqualsToken || kind === ts3.SyntaxKind.EqualsEqualsToken || kind === ts3.SyntaxKind.ExclamationEqualsToken || kind === ts3.SyntaxKind.LessThanToken || kind === ts3.SyntaxKind.GreaterThanToken || kind === ts3.SyntaxKind.LessThanEqualsToken || kind === ts3.SyntaxKind.GreaterThanEqualsToken || kind === ts3.SyntaxKind.AmpersandAmpersandToken || kind === ts3.SyntaxKind.BarBarToken || kind === ts3.SyntaxKind.QuestionQuestionToken || kind === ts3.SyntaxKind.InstanceOfKeyword) {
       const side = (value) => isPredicateExpression(value) || isPredicateAtom(value);
       return side(node.left) && side(node.right);
     }
     return false;
   }
-  if (ts4.isCallExpression(node)) {
+  if (ts3.isCallExpression(node)) {
     return isAllowedTypeCall(node.expression) && node.arguments.every(
       (argument) => isPredicateExpression(argument) || isPredicateAtom(argument)
     );
@@ -1241,15 +1185,15 @@ var bodyHasDisallowedControl = (body) => {
   let found2 = false;
   const visit = (node) => {
     if (found2) return;
-    if (ts4.isAwaitExpression(node) || ts4.isYieldExpression(node) || ts4.isThrowStatement(node) || ts4.isTryStatement(node) || ts4.isNewExpression(node)) {
+    if (ts3.isAwaitExpression(node) || ts3.isYieldExpression(node) || ts3.isThrowStatement(node) || ts3.isTryStatement(node) || ts3.isNewExpression(node)) {
       found2 = true;
       return;
     }
-    if (ts4.isBinaryExpression(node) && node.operatorToken.kind === ts4.SyntaxKind.EqualsToken) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken) {
       found2 = true;
       return;
     }
-    ts4.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
   visit(body);
   return found2;
@@ -1258,7 +1202,7 @@ var isObjectEntriesWrapper = (body) => {
   const returned = singleReturnedExpression(body);
   if (!returned) return false;
   let current = peel(returned);
-  while (ts4.isCallExpression(current) && ts4.isPropertyAccessExpression(current.expression)) {
+  while (ts3.isCallExpression(current) && ts3.isPropertyAccessExpression(current.expression)) {
     const method = current.expression.name.getText();
     if (method === "filter" || method === "map" || method === "flatMap") {
       current = peel(current.expression.expression);
@@ -1266,116 +1210,50 @@ var isObjectEntriesWrapper = (body) => {
     }
     break;
   }
-  if (!ts4.isCallExpression(current) || !ts4.isPropertyAccessExpression(current.expression)) {
+  if (!ts3.isCallExpression(current) || !ts3.isPropertyAccessExpression(current.expression)) {
     return false;
   }
-  return ts4.isIdentifier(current.expression.expression) && current.expression.expression.text === "Object" && ts4.isIdentifier(current.expression.name) && (current.expression.name.text === "entries" || current.expression.name.text === "keys" || current.expression.name.text === "values");
-};
-var SVELTE_REACTIVE_CALLBACKS = /* @__PURE__ */ new Map([
-  ["derived", { name: "$derived", reason: "svelte $derived callback", kind: "derived" }],
-  ["user_effect", { name: "$effect", reason: "svelte $effect callback", kind: "effect" }],
-  [
-    "user_pre_effect",
-    { name: "$effect.pre", reason: "svelte $effect.pre callback", kind: "effect.pre" }
-  ]
-]);
-var SVELTE_EVENT_CALLBACKS = /* @__PURE__ */ new Set(["delegated", "event"]);
-var parameterNames = (node) => {
-  const names = [];
-  for (const parameter of node.parameters) {
-    if (ts4.isIdentifier(parameter.name)) names.push(parameter.name.text);
-  }
-  return names;
-};
-var isSvelteComponentWrapper = (node) => {
-  const names = parameterNames(node);
-  return names.includes("$$anchor") && names.includes("$$props");
-};
-var isSvelteGeneratedBlock = (node) => {
-  const names = parameterNames(node);
-  if (names.includes("$$props")) return false;
-  return names.includes("$$anchor") || names.includes("$$render");
-};
-var isSvelteChildPropThunk = (node) => {
-  const parent = node.parent;
-  if (!parent || !ts4.isPropertyAssignment(parent)) return false;
-  const object = parent.parent;
-  if (!object || !ts4.isObjectLiteralExpression(object)) return false;
-  const call = object.parent;
-  if (!call || !ts4.isCallExpression(call)) return false;
-  return call.arguments.some((argument) => argument === object);
+  return ts3.isIdentifier(current.expression.expression) && current.expression.expression.text === "Object" && ts3.isIdentifier(current.expression.name) && (current.expression.name.text === "entries" || current.expression.name.text === "keys" || current.expression.name.text === "values");
 };
 var isSimpleReadBody = (body) => {
   const returned = singleReturnedExpression(body);
   if (!returned || bodyHasDisallowedControl(body)) return false;
   const value = peel(returned);
-  if (ts4.isIdentifier(value)) return true;
-  if (ts4.isPropertyAccessExpression(value) && isPredicateAtom(value)) return true;
-  if (!ts4.isCallExpression(value) || value.arguments.length !== 1) return false;
+  if (ts3.isIdentifier(value)) return true;
+  if (ts3.isPropertyAccessExpression(value) && isPredicateAtom(value)) return true;
+  if (!ts3.isCallExpression(value) || value.arguments.length !== 1) return false;
   const argument = value.arguments[0];
   if (!argument) return false;
-  if (!ts4.isPropertyAccessExpression(value.expression) || !ts4.isIdentifier(value.expression.expression)) {
+  if (!ts3.isPropertyAccessExpression(value.expression) || !ts3.isIdentifier(value.expression.expression)) {
     return false;
   }
-  return value.expression.expression.text === "$" && ts4.isIdentifier(value.expression.name) && value.expression.name.text === "get" && ts4.isIdentifier(peel(argument));
+  return value.expression.expression.text === "$" && ts3.isIdentifier(value.expression.name) && value.expression.name.text === "get" && ts3.isIdentifier(peel(argument));
 };
-var classifyBody = (node, name, sourceFile, filePath) => {
-  if (isSvelteComponentWrapper(node)) {
-    return { captureClass: "structure", captureReason: "svelte component wrapper" };
-  }
-  if (isSvelteCompiledPath(filePath) && /^\$[A-Za-z]/.test(name)) {
-    return { captureClass: "skip", captureReason: "svelte store subscription" };
-  }
-  if (isSvelteCompiledPath(filePath)) {
-    if (ts4.isGetAccessorDeclaration(node) || ts4.isSetAccessorDeclaration(node)) {
-      return { captureClass: "skip", captureReason: "svelte generated accessor" };
-    }
-    if (isSvelteGeneratedBlock(node)) {
-      return { captureClass: "skip", captureReason: "svelte generated block" };
-    }
-    if (isSvelteChildPropThunk(node)) {
-      const returned2 = singleReturnedExpression(node.body);
-      if (isLiteralOnlyBody(node.body) || isIdentityFunction(node) || isSimpleReadBody(node.body) || returned2 !== void 0 && isPredicateExpression(returned2) && !bodyHasDisallowedControl(node.body)) {
-        return { captureClass: "skip", captureReason: "svelte prop thunk" };
-      }
-      return { captureClass: "full", captureReason: "svelte user callback" };
-    }
-  }
-  if (isSvelteCompiledPath(filePath)) {
-    const runtimeMethod = svelteRuntimeMethod(node);
-    if (runtimeMethod) {
-      const reactive = SVELTE_REACTIVE_CALLBACKS.get(runtimeMethod);
-      if (reactive) {
-        if (isLiteralOnlyBody(node.body)) {
-          return { captureClass: "skip", captureReason: "literal-only return" };
-        }
-        return {
-          captureClass: "reactive-sparse",
-          captureReason: reactive.reason,
-          inferredName: name === "anonymous" ? reactive.name : void 0,
-          reactiveKind: reactive.kind
-        };
-      }
-      if (SVELTE_EVENT_CALLBACKS.has(runtimeMethod)) {
-        if (isLiteralOnlyBody(node.body)) {
-          return { captureClass: "skip", captureReason: "literal-only return" };
-        }
-        return { captureClass: "full", captureReason: "svelte user callback" };
-      }
-      return { captureClass: "skip", captureReason: "svelte generated callback" };
-    }
-    if (enclosingSvelteRuntimeMethod(node)) {
-      return { captureClass: "skip", captureReason: "svelte generated callback" };
-    }
-  }
-  if (isLiteralOnlyBody(node.body)) {
-    return { captureClass: "skip", captureReason: "literal-only return" };
+var classifyBody = (node, name, sourceFile, filePath, policy) => {
+  const returned = singleReturnedExpression(node.body);
+  const body = {
+    isLiteralOnly: isLiteralOnlyBody(node.body),
+    isIdentity: isIdentityFunction(node),
+    isSimpleRead: isSimpleReadBody(node.body),
+    isPredicate: Boolean(
+      returned && isPredicateExpression(returned) && !bodyHasDisallowedControl(node.body)
+    )
+  };
+  const decided = policy?.classifyFunction({ node, sourceFile, filePath, name, body });
+  if (decided) {
+    return {
+      captureClass: decided.captureClass,
+      captureReason: decided.captureReason,
+      inferredName: decided.inferredName,
+      reactiveKind: decided.reactiveKind,
+      compilerRole: decided.role,
+      useSyntheticLocation: decided.useSyntheticLocation
+    };
   }
   if (isIdentityFunction(node)) {
     return { captureClass: "structure", captureReason: "identity wrapper" };
   }
-  const returned = singleReturnedExpression(node.body);
-  if (returned && isPredicateExpression(returned) && !bodyHasDisallowedControl(node.body)) {
+  if (body.isPredicate) {
     return { captureClass: "structure", captureReason: "tiny predicate" };
   }
   if (isObjectEntriesWrapper(node.body) && !bodyHasDisallowedControl(node.body)) {
@@ -1386,29 +1264,24 @@ var classifyBody = (node, name, sourceFile, filePath) => {
   }
   return { captureClass: "full", captureReason: "application function" };
 };
-var classifyFunctions = (source, filePath, mapLocation) => {
+var classifyFunctions = (source, filePath, mapLocation, policy) => {
   const sourceFile = parseSource(source, filePath);
   const absolutePath = resolve3(filePath);
   const classifications = [];
   const visit = (node) => {
     if (isSupportedFunction(node) && node.body) {
-      let location;
-      if (isSvelteComponentWrapper(node)) {
-        location = { filePath: absolutePath, line: 1, column: 1 };
-      } else {
-        location = mappedLocation(
-          sourceFile,
-          functionLocationPosition(node, sourceFile),
-          absolutePath,
-          mapLocation
-        );
-        if (!location) {
-          ts4.forEachChild(node, visit);
-          return;
-        }
-      }
       const rawName = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
-      const classified = classifyBody(node, rawName, sourceFile, filePath);
+      const classified = classifyBody(node, rawName, sourceFile, filePath, policy);
+      const location = classified.useSyntheticLocation ? { filePath: absolutePath, line: 1, column: 1 } : mappedLocation(
+        sourceFile,
+        functionLocationPosition(node, sourceFile),
+        absolutePath,
+        mapLocation
+      );
+      if (!location) {
+        ts3.forEachChild(node, visit);
+        return;
+      }
       const name = classified.inferredName ?? rawName;
       const plan = encodeFunctionPlan({
         filePath: location.filePath,
@@ -1428,23 +1301,14 @@ var classifyFunctions = (source, filePath, mapLocation) => {
         end: node.end,
         bodyStart: node.body.getStart(sourceFile),
         bodyEnd: node.body.end,
-        ...classified.reactiveKind ? { reactiveKind: classified.reactiveKind } : {}
+        ...classified.reactiveKind ? { reactiveKind: classified.reactiveKind } : {},
+        ...classified.compilerRole ? { compilerRole: classified.compilerRole } : {}
       });
     }
-    ts4.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
   visit(sourceFile);
-  const hasUserWork = classifications.some(
-    (item) => item.captureClass === "full" || item.captureClass === "reactive-sparse"
-  );
-  if (!hasUserWork) {
-    for (const item of classifications) {
-      if (item.captureReason === "svelte component wrapper") {
-        item.captureClass = "skip";
-        item.captureReason = "svelte presentational wrapper";
-      }
-    }
-  }
+  policy?.finalizeClassifications?.(classifications);
   return classifications;
 };
 
@@ -1495,7 +1359,7 @@ var applyEdits = (source, edits) => {
 };
 var textOf = (edit) => edit.text;
 
-// ../node_modules/.bun/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+// ../../node_modules/.bun/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
 var SetArray = class {
   constructor() {
     this._indexes = { __proto__: null };
@@ -1775,11 +1639,11 @@ var exactTransformMap = (original, generated, file, edits) => {
 import { basename as basename2 } from "node:path";
 
 // ../instrumentation/src/browser-function-edits.ts
-import ts10 from "typescript";
+import ts9 from "typescript";
 
 // ../instrumentation/src/suspension-whitelist.ts
-import ts5 from "typescript";
-var nodeFlags = ts5.NodeFlags;
+import ts4 from "typescript";
+var nodeFlags = ts4.NodeFlags;
 var AWAIT_USING_FLAG = nodeFlags.AwaitUsing ?? 0;
 var USING_FLAG = nodeFlags.Using ?? 0;
 var KNOWN_SUSPENSION_KIND_NAMES = [
@@ -1789,25 +1653,25 @@ var KNOWN_SUSPENSION_KIND_NAMES = [
   "YieldKeyword",
   "UsingKeyword"
 ];
-var isFunctionLike2 = (node) => ts5.isFunctionLike(node);
-var isAsyncFunctionLike = (node) => (ts5.getCombinedModifierFlags(node) & ts5.ModifierFlags.Async) !== 0;
-var isAsyncGeneratorLike = (node) => isFunctionLike2(node) && isAsyncFunctionLike(node) && "asteriskToken" in node && Boolean(node.asteriskToken);
+var isFunctionLike = (node) => ts4.isFunctionLike(node);
+var isAsyncFunctionLike = (node) => (ts4.getCombinedModifierFlags(node) & ts4.ModifierFlags.Async) !== 0;
+var isAsyncGeneratorLike = (node) => isFunctionLike(node) && isAsyncFunctionLike(node) && "asteriskToken" in node && Boolean(node.asteriskToken);
 var visitOwnBody = (node, visitNode) => {
   if (!node.body) return;
   const visit = (candidate) => {
-    if (candidate !== node && isFunctionLike2(candidate)) {
+    if (candidate !== node && isFunctionLike(candidate)) {
       visitNode(candidate);
       return;
     }
     if (visitNode(candidate)) return;
-    ts5.forEachChild(candidate, visit);
+    ts4.forEachChild(candidate, visit);
   };
   visit(node.body);
 };
 var nestedFunctionSpans = (node, sourceFile) => {
   const spans = [];
   visitOwnBody(node, (candidate) => {
-    if (candidate !== node && isFunctionLike2(candidate)) {
+    if (candidate !== node && isFunctionLike(candidate)) {
       spans.push([candidate.getStart(sourceFile), candidate.end]);
     }
     return void 0;
@@ -1828,16 +1692,16 @@ var slicesOutside = (start, end, spans) => {
 };
 var sliceHasAwaitKeyword = (source, start, end) => {
   if (end <= start) return false;
-  const scanner = ts5.createScanner(
-    ts5.ScriptTarget.Latest,
+  const scanner = ts4.createScanner(
+    ts4.ScriptTarget.Latest,
     true,
-    ts5.LanguageVariant.Standard,
+    ts4.LanguageVariant.Standard,
     source.slice(start, end)
   );
   while (true) {
     const token = scanner.scan();
-    if (token === ts5.SyntaxKind.EndOfFileToken) return false;
-    if (token === ts5.SyntaxKind.AwaitKeyword) return true;
+    if (token === ts4.SyntaxKind.EndOfFileToken) return false;
+    if (token === ts4.SyntaxKind.AwaitKeyword) return true;
   }
 };
 var ownBodyHasAwaitKeyword = (node, sourceFile) => {
@@ -1855,7 +1719,7 @@ var isAwaitUsingList = (node) => {
   return (node.flags & AWAIT_USING_FLAG) === AWAIT_USING_FLAG && (node.flags & USING_FLAG) !== 0;
 };
 var unknownSuspensionKind = (node) => {
-  const name = ts5.SyntaxKind[node.kind];
+  const name = ts4.SyntaxKind[node.kind];
   if (typeof name !== "string" || !/Await|Yield|Using/.test(name)) return false;
   return !KNOWN_SUSPENSION_KIND_NAMES.includes(name);
 };
@@ -1868,9 +1732,9 @@ var ownSuspensionFacts = (node, sourceFile) => {
     awaitKeyword: ownBodyHasAwaitKeyword(node, sourceFile)
   };
   visitOwnBody(node, (candidate) => {
-    if (ts5.isAwaitExpression(candidate)) facts.awaitExpressions = true;
-    if (ts5.isForOfStatement(candidate) && candidate.awaitModifier) facts.forAwait = true;
-    if (ts5.isVariableDeclarationList(candidate) && isAwaitUsingList(candidate)) {
+    if (ts4.isAwaitExpression(candidate)) facts.awaitExpressions = true;
+    if (ts4.isForOfStatement(candidate) && candidate.awaitModifier) facts.forAwait = true;
+    if (ts4.isVariableDeclarationList(candidate) && isAwaitUsingList(candidate)) {
       facts.awaitUsing = true;
     }
     if (unknownSuspensionKind(candidate)) facts.unknown = true;
@@ -1881,7 +1745,7 @@ var ownSuspensionFacts = (node, sourceFile) => {
 var bodyHasDirectEval = (node) => {
   let found2 = false;
   visitOwnBody(node, (candidate) => {
-    if (ts5.isCallExpression(candidate) && ts5.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
+    if (ts4.isCallExpression(candidate) && ts4.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
       found2 = true;
     }
     return found2;
@@ -1904,23 +1768,23 @@ var decideAsyncInstrumentation = (node, sourceFile) => {
 };
 
 // ../instrumentation/src/transform-source.ts
-import ts9 from "typescript";
+import ts8 from "typescript";
 
 // ../instrumentation/src/parameter-initializer-may-run-code.ts
-import ts6 from "typescript";
+import ts5 from "typescript";
 
 // ../instrumentation/src/verify-instrumentation-isomorphism.ts
-import ts7 from "typescript";
+import ts6 from "typescript";
 
 // ../instrumentation/src/verify-transformed-source.ts
-import ts8 from "typescript";
-var transpileForVerification = (filePath, code) => ts8.transpileModule(code, {
+import ts7 from "typescript";
+var transpileForVerification = (filePath, code) => ts7.transpileModule(code, {
   compilerOptions: {
     // ES2020 downlevel keeps native @decorators out of `new Function`.
-    target: ts8.ScriptTarget.ES2020,
-    module: ts8.ModuleKind.ESNext,
+    target: ts7.ScriptTarget.ES2020,
+    module: ts7.ModuleKind.ESNext,
     allowJs: true,
-    jsx: ts8.JsxEmit.React,
+    jsx: ts7.JsxEmit.React,
     experimentalDecorators: true
   },
   reportDiagnostics: true,
@@ -1928,7 +1792,7 @@ var transpileForVerification = (filePath, code) => ts8.transpileModule(code, {
 });
 var hasScanOrParseError = (diagnostics) => Boolean(
   diagnostics?.some(
-    (diagnostic) => diagnostic.category === ts8.DiagnosticCategory.Error && diagnostic.code < 2e3
+    (diagnostic) => diagnostic.category === ts7.DiagnosticCategory.Error && diagnostic.code < 2e3
   )
 );
 var scriptBodyForEngine = (emitted) => (
@@ -1937,39 +1801,39 @@ var scriptBodyForEngine = (emitted) => (
 );
 var looksTyped = (filePath) => /\.[cm]?tsx?$/i.test(filePath);
 var scriptKindFor2 = (filePath) => {
-  if (/\.tsx$/i.test(filePath)) return ts8.ScriptKind.TSX;
-  if (/\.jsx$/i.test(filePath)) return ts8.ScriptKind.JSX;
-  if (/\.[cm]?ts$/i.test(filePath)) return ts8.ScriptKind.TS;
-  return ts8.ScriptKind.JS;
+  if (/\.tsx$/i.test(filePath)) return ts7.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts7.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts7.ScriptKind.TS;
+  return ts7.ScriptKind.JS;
 };
-var isIterationStatement = (node) => ts8.isForStatement(node) || ts8.isForOfStatement(node) || ts8.isForInStatement(node) || ts8.isWhileStatement(node) || ts8.isDoStatement(node);
+var isIterationStatement = (node) => ts7.isForStatement(node) || ts7.isForOfStatement(node) || ts7.isForInStatement(node) || ts7.isWhileStatement(node) || ts7.isDoStatement(node);
 var unwrapLabeled = (node) => {
   let current = node;
-  while (ts8.isLabeledStatement(current)) current = current.statement;
+  while (ts7.isLabeledStatement(current)) current = current.statement;
   return current;
 };
 var hasInvalidLabelJump = (sourceFile) => {
   const visit = (node, labels) => {
-    if (ts8.isFunctionLike(node)) {
+    if (ts7.isFunctionLike(node)) {
       let nestedInvalid = false;
-      ts8.forEachChild(node, (child) => {
+      ts7.forEachChild(node, (child) => {
         if (visit(child, /* @__PURE__ */ new Map())) nestedInvalid = true;
       });
       return nestedInvalid;
     }
-    if (ts8.isLabeledStatement(node)) {
+    if (ts7.isLabeledStatement(node)) {
       const next = new Map(labels);
       next.set(node.label.text, isIterationStatement(unwrapLabeled(node.statement)));
       return visit(node.statement, next);
     }
-    if (ts8.isContinueStatement(node) && node.label) {
+    if (ts7.isContinueStatement(node) && node.label) {
       if (labels.get(node.label.text) !== true) return true;
     }
-    if (ts8.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
+    if (ts7.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
       return true;
     }
     let invalid = false;
-    ts8.forEachChild(node, (child) => {
+    ts7.forEachChild(node, (child) => {
       if (visit(child, labels)) invalid = true;
     });
     return invalid;
@@ -2012,10 +1876,10 @@ var UNTERMINATED_BARE_LEAVE = /\breturn\s+__rasputin\w*\.leave\(\)(?!\s*;|\()/;
 var transformedSourceIsInvalid = (filePath, code) => {
   if (GLUED_INSTRUMENTATION.test(code)) return true;
   if (UNTERMINATED_BARE_LEAVE.test(code)) return true;
-  const sourceFile = ts8.createSourceFile(
+  const sourceFile = ts7.createSourceFile(
     filePath,
     code,
-    ts8.ScriptTarget.Latest,
+    ts7.ScriptTarget.Latest,
     true,
     scriptKindFor2(filePath)
   );
@@ -2041,8 +1905,8 @@ var REACTIVE_REG = "__rasputinReg";
 var OBSERVE_GUARD = "globalThis.__rasputinO??=function(i,v){return v};";
 var STRUCT_GUARD = "globalThis.__rasputinK??=function(o){return o};";
 var REACTIVE_GUARD = "globalThis.__rasputinR??=function(){return 1};globalThis.__rasputinL??=function(i,v){return v};globalThis.__rasputinT??=function(){};globalThis.__rasputinD??=function(){};globalThis.__rasputinReg??=function(){};";
-var isWrapTarget = (node) => (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isMethodDeclaration(node) || ts10.isGetAccessorDeclaration(node) || ts10.isSetAccessorDeclaration(node)) && node.body !== void 0;
-var isDirectivePrologue = (statement) => ts10.isExpressionStatement(statement) && ts10.isStringLiteral(statement.expression);
+var isWrapTarget = (node) => (ts9.isFunctionDeclaration(node) || ts9.isFunctionExpression(node) || ts9.isArrowFunction(node) || ts9.isMethodDeclaration(node) || ts9.isGetAccessorDeclaration(node) || ts9.isSetAccessorDeclaration(node)) && node.body !== void 0;
+var isDirectivePrologue = (statement) => ts9.isExpressionStatement(statement) && ts9.isStringLiteral(statement.expression);
 var insertPositionAfterPrologue = (source, sourceFile) => {
   const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
   let end = shebangEnd;
@@ -2069,7 +1933,7 @@ var insertAfterSuperOrPrologue = (body, sourceFile) => {
   const end = functionBodyPrologueEnd(body, sourceFile);
   for (const statement of body.statements) {
     if (isDirectivePrologue(statement)) continue;
-    if (ts10.isExpressionStatement(statement) && ts10.isCallExpression(statement.expression) && statement.expression.expression.kind === ts10.SyntaxKind.SuperKeyword) {
+    if (ts9.isExpressionStatement(statement) && ts9.isCallExpression(statement.expression) && statement.expression.expression.kind === ts9.SyntaxKind.SuperKeyword) {
       return statement.end;
     }
     break;
@@ -2077,14 +1941,14 @@ var insertAfterSuperOrPrologue = (body, sourceFile) => {
   return end;
 };
 var functionRef = (node) => {
-  if (node.name && ts10.isIdentifier(node.name)) {
-    if (ts10.isGetAccessorDeclaration(node) || ts10.isSetAccessorDeclaration(node) || ts10.isMethodDeclaration(node)) {
+  if (node.name && ts9.isIdentifier(node.name)) {
+    if (ts9.isGetAccessorDeclaration(node) || ts9.isSetAccessorDeclaration(node) || ts9.isMethodDeclaration(node)) {
       return void 0;
     }
     return node.name.text;
   }
   const parent = node.parent;
-  if (ts10.isVariableDeclaration(parent) && ts10.isIdentifier(parent.name) && parent.initializer === node) {
+  if (ts9.isVariableDeclaration(parent) && ts9.isIdentifier(parent.name) && parent.initializer === node) {
     return parent.name.text;
   }
   return void 0;
@@ -2097,17 +1961,17 @@ var matchingFunction = (sourceFile, item) => {
       found2 = node;
       return;
     }
-    ts10.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(sourceFile);
   return found2;
 };
-var isStaticPropertyName = (name) => ts10.isIdentifier(name) || ts10.isStringLiteral(name) || ts10.isNoSubstitutionTemplateLiteral(name) || ts10.isNumericLiteral(name);
+var isStaticPropertyName = (name) => ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNoSubstitutionTemplateLiteral(name) || ts9.isNumericLiteral(name);
 var canReconstructBinding = (name) => {
-  if (ts10.isIdentifier(name)) return true;
-  if (ts10.isArrayBindingPattern(name)) {
+  if (ts9.isIdentifier(name)) return true;
+  if (ts9.isArrayBindingPattern(name)) {
     return name.elements.every(
-      (element) => ts10.isOmittedExpression(element) || canReconstructBinding(element.name)
+      (element) => ts9.isOmittedExpression(element) || canReconstructBinding(element.name)
     );
   }
   return name.elements.every((element) => {
@@ -2117,16 +1981,16 @@ var canReconstructBinding = (name) => {
 };
 var REDACTED_ARG_EXPR = 'Symbol.for("rasputin.redacted.v1")';
 var staticBindingKey = (name) => {
-  if (ts10.isIdentifier(name)) return name.text;
-  if (ts10.isStringLiteral(name) || ts10.isNoSubstitutionTemplateLiteral(name)) return name.text;
-  if (ts10.isNumericLiteral(name)) return name.text;
+  if (ts9.isIdentifier(name)) return name.text;
+  if (ts9.isStringLiteral(name) || ts9.isNoSubstitutionTemplateLiteral(name)) return name.text;
+  if (ts9.isNumericLiteral(name)) return name.text;
   return void 0;
 };
 var bindingHasSensitiveName = (name) => {
-  if (ts10.isIdentifier(name)) return propertyNameIsSensitive(name.text);
-  if (ts10.isArrayBindingPattern(name)) {
+  if (ts9.isIdentifier(name)) return propertyNameIsSensitive(name.text);
+  if (ts9.isArrayBindingPattern(name)) {
     return name.elements.some(
-      (element) => !ts10.isOmittedExpression(element) && bindingHasSensitiveName(element.name)
+      (element) => !ts9.isOmittedExpression(element) && bindingHasSensitiveName(element.name)
     );
   }
   return name.elements.some((element) => {
@@ -2136,12 +2000,12 @@ var bindingHasSensitiveName = (name) => {
   });
 };
 var capturedBinding = (name, sourceFile) => {
-  if (ts10.isIdentifier(name)) {
+  if (ts9.isIdentifier(name)) {
     return propertyNameIsSensitive(name.text) ? REDACTED_ARG_EXPR : name.text;
   }
-  if (ts10.isArrayBindingPattern(name)) {
+  if (ts9.isArrayBindingPattern(name)) {
     const values = name.elements.map((element) => {
-      if (ts10.isOmittedExpression(element)) return "";
+      if (ts9.isOmittedExpression(element)) return "";
       const value = capturedBinding(element.name, sourceFile);
       return element.dotDotDotToken ? `...${value}` : value;
     });
@@ -2149,14 +2013,14 @@ var capturedBinding = (name, sourceFile) => {
   }
   const properties = name.elements.map((element) => {
     const key = element.propertyName ? staticBindingKey(element.propertyName) : void 0;
-    const sensitive = key !== void 0 && propertyNameIsSensitive(key) || ts10.isIdentifier(element.name) && propertyNameIsSensitive(element.name.text);
+    const sensitive = key !== void 0 && propertyNameIsSensitive(key) || ts9.isIdentifier(element.name) && propertyNameIsSensitive(element.name.text);
     if (element.dotDotDotToken) {
       return `...${sensitive ? REDACTED_ARG_EXPR : capturedBinding(element.name, sourceFile)}`;
     }
     if (!element.propertyName) {
-      return sensitive && ts10.isIdentifier(element.name) ? `${element.name.text}:${REDACTED_ARG_EXPR}` : capturedBinding(element.name, sourceFile);
+      return sensitive && ts9.isIdentifier(element.name) ? `${element.name.text}:${REDACTED_ARG_EXPR}` : capturedBinding(element.name, sourceFile);
     }
-    const printedKey = ts10.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText(sourceFile);
+    const printedKey = ts9.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText(sourceFile);
     return `${printedKey}:${sensitive ? REDACTED_ARG_EXPR : capturedBinding(element.name, sourceFile)}`;
   });
   return `{${properties.join(",")}}`;
@@ -2164,12 +2028,12 @@ var capturedBinding = (name, sourceFile) => {
 var captureArgs = (node) => {
   const sourceFile = node.getSourceFile();
   const params = node.parameters.filter(
-    (parameter) => !(ts10.isIdentifier(parameter.name) && parameter.name.text === "this")
+    (parameter) => !(ts9.isIdentifier(parameter.name) && parameter.name.text === "this")
   );
   const reconstructable = params.every((parameter) => canReconstructBinding(parameter.name));
   const sensitive = params.some((parameter) => bindingHasSensitiveName(parameter.name));
   if (!reconstructable) {
-    if (ts10.isArrowFunction(node) || sensitive) {
+    if (ts9.isArrowFunction(node) || sensitive) {
       return {
         args: `[${Array.from({ length: params.length }, () => "void 0").join(",")}]`,
         omitValues: true
@@ -2177,7 +2041,7 @@ var captureArgs = (node) => {
     }
     return { args: "arguments", omitValues: false };
   }
-  if (!ts10.isArrowFunction(node) && !sensitive) {
+  if (!ts9.isArrowFunction(node) && !sensitive) {
     return { args: "arguments", omitValues: false };
   }
   const values = params.map((parameter) => {
@@ -2188,16 +2052,16 @@ var captureArgs = (node) => {
 };
 var walkOwnBody = (node, visitNode) => {
   const visit = (candidate) => {
-    if (candidate !== node && ts10.isFunctionLike(candidate)) return;
+    if (candidate !== node && ts9.isFunctionLike(candidate)) return;
     visitNode(candidate);
-    ts10.forEachChild(candidate, visit);
+    ts9.forEachChild(candidate, visit);
   };
   visit(node.body);
 };
 var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
-  if (!ts10.isBlock(node.body)) return;
+  if (!ts9.isBlock(node.body)) return;
   walkOwnBody(node, (candidate) => {
-    if (!ts10.isReturnStatement(candidate) || !candidate.expression) return;
+    if (!ts9.isReturnStatement(candidate) || !candidate.expression) return;
     wrap(
       edits,
       candidate.expression.getStart(sourceFile),
@@ -2210,7 +2074,7 @@ var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
 };
 var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
   walkOwnBody(node, (candidate) => {
-    if (!ts10.isAwaitExpression(candidate)) return;
+    if (!ts9.isAwaitExpression(candidate)) return;
     wrap(
       edits,
       candidate.expression.getStart(sourceFile),
@@ -2231,7 +2095,7 @@ var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
 };
 var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) => {
   walkOwnBody(node, (candidate) => {
-    if (!ts10.isTryStatement(candidate)) return;
+    if (!ts9.isTryStatement(candidate)) return;
     for (const block of [candidate.catchClause?.block, candidate.finallyBlock]) {
       if (!block) continue;
       edits.push({
@@ -2246,9 +2110,9 @@ var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) =>
   });
 };
 var collectReactiveReturnWraps = (node, sourceFile, siteId, edits, depth) => {
-  if (!ts10.isBlock(node.body)) return;
+  if (!ts9.isBlock(node.body)) return;
   walkOwnBody(node, (candidate) => {
-    if (!ts10.isReturnStatement(candidate)) return;
+    if (!ts9.isReturnStatement(candidate)) return;
     if (!candidate.expression) {
       edits.push({
         position: candidate.getStart(sourceFile),
@@ -2295,7 +2159,7 @@ var toManifestFunction = (item, node, sourceFile, asyncFunction, instrumented, m
     asyncFunction
   };
 };
-var collectCallerSites = (sourceFile, classifications, functions, absolutePath, mapLocation) => {
+var collectCallerSites = (sourceFile, classifications, functions, absolutePath, mapLocation, policy) => {
   const bySpan = /* @__PURE__ */ new Map();
   const classified = new Map(
     classifications.map((item) => [`${item.start}:${item.end}`, item])
@@ -2308,31 +2172,33 @@ var collectCallerSites = (sourceFile, classifications, functions, absolutePath,
   const callSites = [];
   const destructures = [];
   const collectContext = { sourceFile, absolutePath, mapLocation };
-  const svelteFile = isSvelteCompiledPath(absolutePath);
-  const identifierCallees = svelteFile ? svelteGeneratedIdentifierCallees(sourceFile) : void 0;
   const visit = (node, caller) => {
     if (isWrapTarget(node)) {
       const item = classified.get(`${node.getStart(sourceFile)}:${node.end}`);
       if (item) {
         const fn = bySpan.get(`${item.start}:${item.end}`);
         const next = fn && fn.instrumented !== false ? fn : caller;
-        ts10.forEachChild(node, (child) => visit(child, next));
+        ts9.forEachChild(node, (child) => visit(child, next));
         return;
       }
     }
-    if (caller && (ts10.isCallExpression(node) || ts10.isNewExpression(node))) {
-      if (svelteFile && isSvelteCompilerCall(node, sourceFile, identifierCallees)) {
-        ts10.forEachChild(node, (child) => visit(child, caller));
+    if (caller && (ts9.isCallExpression(node) || ts9.isNewExpression(node))) {
+      if (policy?.isCompilerCall({
+        node,
+        sourceFile,
+        filePath: absolutePath
+      })) {
+        ts9.forEachChild(node, (child) => visit(child, caller));
         return;
       }
       const site = collectCallSite(node, caller, collectContext);
       if (site) callSites.push(site);
     }
-    if (caller && ts10.isVariableDeclaration(node)) {
+    if (caller && ts9.isVariableDeclaration(node)) {
       const destructure = collectParamDestructure(node, caller, collectContext);
       if (destructure) destructures.push(destructure);
     }
-    ts10.forEachChild(node, (child) => visit(child, caller));
+    ts9.forEachChild(node, (child) => visit(child, caller));
   };
   visit(sourceFile, void 0);
   return { callSites, destructures };
@@ -2393,7 +2259,7 @@ var collectBrowserFunctionEdits = (source, sourceFile, classifications, moduleIn
       const leave = `${REACTIVE_LEAVE}(${siteId})`;
       const fail = `${REACTIVE_THROW}(${siteId},${errorName})`;
       const epilogue2 = `}catch(${errorName}){${fail};throw ${errorName};}finally{${REACTIVE_DONE}()}`;
-      if (ts10.isBlock(node.body)) {
+      if (ts9.isBlock(node.body)) {
         wrap(
           edits,
           node.body.getStart(sourceFile) + 1,
@@ -2438,7 +2304,7 @@ var collectBrowserFunctionEdits = (source, sourceFile, classifications, moduleIn
       failArgs,
       decision.action === "suspend_resume"
     );
-    if (ts10.isBlock(node.body)) {
+    if (ts9.isBlock(node.body)) {
       const prologueAt = insertAfterSuperOrPrologue(node.body, sourceFile);
       const closeAt = node.body.end - 1;
       wrap(edits, prologueAt, closeAt, `;const ${handleName}=${enterCall};try{`, epilogue, 0);
@@ -2496,7 +2362,8 @@ var collectBrowserFunctionEdits = (source, sourceFile, classifications, moduleIn
     classifications,
     functions,
     classifications[0]?.filePath ?? "",
-    options.mapLocation
+    options.mapLocation,
+    options.policy
   );
   return {
     edits,
@@ -2507,42 +2374,42 @@ var collectBrowserFunctionEdits = (source, sourceFile, classifications, moduleIn
 };
 
 // ../instrumentation/src/json-producer-sites.ts
-import ts11 from "typescript";
+import ts10 from "typescript";
 var JSON_METHOD_CALLEE = "globalThis.__rasputinM";
 var JSON_AWAIT_CALLEE = "globalThis.__rasputinA";
 var JSON_ADOPT_CALLEE = "globalThis.__rasputinP";
 var JSON_PRODUCER_GUARD = "globalThis.__rasputinM??=function(r,f){return Reflect.apply(f,r,[].slice.call(arguments,2))};globalThis.__rasputinA??=function(v){return v};globalThis.__rasputinP??=function(p){return p};";
 var isSimpleReceiver = (expression) => {
   const receiver = peel(expression);
-  return ts11.isIdentifier(receiver) || receiver.kind === ts11.SyntaxKind.ThisKeyword;
+  return ts10.isIdentifier(receiver) || receiver.kind === ts10.SyntaxKind.ThisKeyword;
 };
-var isSimpleIdentifierCall = (node) => !node.questionDotToken && ts11.isIdentifier(node.expression);
+var isSimpleIdentifierCall = (node) => !node.questionDotToken && ts10.isIdentifier(node.expression);
 var isSimpleMethodCall = (node) => {
   if (node.questionDotToken) return false;
   const callee = node.expression;
-  return ts11.isPropertyAccessExpression(callee) && !callee.questionDotToken && ts11.isIdentifier(callee.name) && !ts11.isPrivateIdentifier(callee.name) && isSimpleReceiver(callee.expression);
+  return ts10.isPropertyAccessExpression(callee) && !callee.questionDotToken && ts10.isIdentifier(callee.name) && !ts10.isPrivateIdentifier(callee.name) && isSimpleReceiver(callee.expression);
 };
 var isSimpleProvenanceCall = (node) => isSimpleIdentifierCall(node) || isSimpleMethodCall(node);
 var isJsonParseCall = (node) => {
   if (!isSimpleMethodCall(node)) return false;
   const callee = node.expression;
-  if (!ts11.isPropertyAccessExpression(callee) || callee.name.text !== "parse") return false;
+  if (!ts10.isPropertyAccessExpression(callee) || callee.name.text !== "parse") return false;
   const object = peel(callee.expression);
-  return ts11.isIdentifier(object) && object.text === "JSON";
+  return ts10.isIdentifier(object) && object.text === "JSON";
 };
 var methodName = (node) => {
   if (!isSimpleMethodCall(node)) return void 0;
   const callee = node.expression;
-  return ts11.isPropertyAccessExpression(callee) ? callee.name.text : void 0;
+  return ts10.isPropertyAccessExpression(callee) ? callee.name.text : void 0;
 };
 var containsNestedAwaitOrFunction = (node) => {
   let found2 = false;
   const visit = (candidate) => {
-    if (candidate !== node && (ts11.isAwaitExpression(candidate) || ts11.isFunctionLike(candidate))) {
+    if (candidate !== node && (ts10.isAwaitExpression(candidate) || ts10.isFunctionLike(candidate))) {
       found2 = true;
       return;
     }
-    if (!found2) ts11.forEachChild(candidate, visit);
+    if (!found2) ts10.forEachChild(candidate, visit);
   };
   visit(node);
   return found2;
@@ -2556,45 +2423,24 @@ var isAwaitExpressionOf = (node) => {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if (ts11.isParenthesizedExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isSatisfiesExpression(parent)) {
+    if (ts10.isParenthesizedExpression(parent) || ts10.isNonNullExpression(parent) || ts10.isAsExpression(parent) || ts10.isTypeAssertionExpression(parent) || ts10.isSatisfiesExpression(parent)) {
       current = parent;
       continue;
     }
-    return ts11.isAwaitExpression(parent) && parent.expression === current;
+    return ts10.isAwaitExpression(parent) && parent.expression === current;
   }
   return false;
 };
-var isDirectSuperCall = (node) => node.expression.kind === ts11.SyntaxKind.SuperKeyword;
-var SVELTE_RUNE_ROOTS = /* @__PURE__ */ new Set([
-  "$state",
-  "$derived",
-  "$effect",
-  "$props",
-  "$bindable",
-  "$inspect",
-  "$host"
-]);
-var isSvelteRuneCall = (node) => {
-  let current = peel(node.expression);
-  while (ts11.isPropertyAccessExpression(current)) {
-    current = peel(current.expression);
-  }
-  return ts11.isIdentifier(current) && SVELTE_RUNE_ROOTS.has(current.text);
-};
-var isSvelteSourcePath = (filePath) => filePath.includes(".svelte");
-var isSvelteCompilerCall2 = (node, filePath) => {
-  if (isSvelteRuneCall(node)) return true;
-  if (!isSvelteSourcePath(filePath)) return false;
-  const callee = peel(node.expression);
-  if (!ts11.isPropertyAccessExpression(callee)) return false;
-  const object = peel(callee.expression);
-  return ts11.isIdentifier(object) && object.text === "$";
+var isDirectSuperCall = (node) => node.expression.kind === ts10.SyntaxKind.SuperKeyword;
+var isPolicyCompilerCall = (node, filePath, sourceFile, policy) => {
+  if (!policy) return false;
+  return policy.isCompilerCall({ node, sourceFile, filePath });
 };
 var outerExpression = (node) => {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if ((ts11.isParenthesizedExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isSatisfiesExpression(parent)) && parent.expression === current) {
+    if ((ts10.isParenthesizedExpression(parent) || ts10.isNonNullExpression(parent) || ts10.isAsExpression(parent) || ts10.isTypeAssertionExpression(parent) || ts10.isSatisfiesExpression(parent)) && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -2606,9 +2452,9 @@ var isReturnedOrBoundCall = (node) => {
   const expression = outerExpression(node);
   const parent = expression.parent;
   if (!parent) return false;
-  if (ts11.isReturnStatement(parent) && parent.expression === expression) return true;
-  if (ts11.isVariableDeclaration(parent) && parent.initializer === expression) return true;
-  if (ts11.isBinaryExpression(parent) && parent.right === expression && parent.operatorToken.kind === ts11.SyntaxKind.EqualsToken) {
+  if (ts10.isReturnStatement(parent) && parent.expression === expression) return true;
+  if (ts10.isVariableDeclaration(parent) && parent.initializer === expression) return true;
+  if (ts10.isBinaryExpression(parent) && parent.right === expression && parent.operatorToken.kind === ts10.SyntaxKind.EqualsToken) {
     return true;
   }
   return false;
@@ -2647,30 +2493,32 @@ var callCanCarryProvenance = (node) => {
   if (name === "json" || name === "parse") return true;
   if (name === "call" || name === "apply") return false;
   const callee = node.expression;
-  if (ts11.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS.has(callee.text);
-  if (ts11.isPropertyAccessExpression(callee)) {
+  if (ts10.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS.has(callee.text);
+  if (ts10.isPropertyAccessExpression(callee)) {
     const object = peel(callee.expression);
-    if (ts11.isIdentifier(object) && NON_PROVENANCE_ROOTS.has(object.text)) {
+    if (ts10.isIdentifier(object) && NON_PROVENANCE_ROOTS.has(object.text)) {
       return object.text === "JSON" && callee.name.text === "parse";
     }
   }
   return true;
 };
-var shouldAdoptCall = (node, filePath) => {
-  if (isAwaitExpressionOf(node) || isDirectSuperCall(node) || isSvelteCompilerCall2(node, filePath)) {
+var shouldAdoptCall = (node, filePath, sourceFile, policy) => {
+  if (isAwaitExpressionOf(node) || isDirectSuperCall(node) || isPolicyCompilerCall(node, filePath, sourceFile, policy)) {
     return false;
   }
-  if (ts11.isComputedPropertyName(outerExpression(node).parent)) return false;
+  if (ts10.isComputedPropertyName(outerExpression(node).parent)) return false;
   if (!isSimpleProvenanceCall(node)) return false;
   return isReturnedOrBoundCall(node) && callCanCarryProvenance(node);
 };
-var shouldAdoptAwaitCall = (node, filePath) => {
-  if (isSvelteCompilerCall2(node, filePath) || !isSimpleProvenanceCall(node)) return false;
+var shouldAdoptAwaitCall = (node, filePath, sourceFile, policy) => {
+  if (isPolicyCompilerCall(node, filePath, sourceFile, policy) || !isSimpleProvenanceCall(node)) {
+    return false;
+  }
   return callCanCarryProvenance(node);
 };
 var replaceProducerCall = (node, sourceFile, receiverName) => {
   const callee = node.expression;
-  if (!ts11.isPropertyAccessExpression(callee)) return node.getText(sourceFile);
+  if (!ts10.isPropertyAccessExpression(callee)) return node.getText(sourceFile);
   const args = node.arguments.map((argument) => argument.getText(sourceFile));
   const extra2 = args.length > 0 ? `,${args.join(",")}` : "";
   const receiver = callee.expression.getText(sourceFile);
@@ -2678,10 +2526,10 @@ var replaceProducerCall = (node, sourceFile, receiverName) => {
   return `((${receiverName})=>${JSON_METHOD_CALLEE}(${receiverName},${method}${extra2}))(${receiver})`;
 };
 var hasBlockBody = (node) => {
-  if (!ts11.isFunctionDeclaration(node) && !ts11.isFunctionExpression(node) && !ts11.isArrowFunction(node) && !ts11.isMethodDeclaration(node) && !ts11.isConstructorDeclaration(node) && !ts11.isGetAccessorDeclaration(node) && !ts11.isSetAccessorDeclaration(node)) {
+  if (!ts10.isFunctionDeclaration(node) && !ts10.isFunctionExpression(node) && !ts10.isArrowFunction(node) && !ts10.isMethodDeclaration(node) && !ts10.isConstructorDeclaration(node) && !ts10.isGetAccessorDeclaration(node) && !ts10.isSetAccessorDeclaration(node)) {
     return false;
   }
-  return node.body !== void 0 && ts11.isBlock(node.body);
+  return node.body !== void 0 && ts10.isBlock(node.body);
 };
 var owningFunctionBody = (node) => {
   let current = node;
@@ -2712,7 +2560,7 @@ var adoptCall = (edits, node, sourceFile, receiverName, fnName, slotName, slot =
   const wrapOpen = (inner) => slot ? `(${slotName}={p:${inner}` : inner;
   const wrapClose = (inner) => slot ? `${inner}},${slotName}.p)` : inner;
   const callee = node.expression;
-  if (ts11.isIdentifier(callee)) {
+  if (ts10.isIdentifier(callee)) {
     wrap(
       edits,
       start,
@@ -2731,7 +2579,7 @@ var adoptCall = (edits, node, sourceFile, receiverName, fnName, slotName, slot =
     });
     return;
   }
-  if (!isSimpleMethodCall(node) || !ts11.isPropertyAccessExpression(callee)) return;
+  if (!isSimpleMethodCall(node) || !ts10.isPropertyAccessExpression(callee)) return;
   const receiver = callee.expression.getText(sourceFile);
   const method = callee.name.text;
   const open = callOpenParen(node, sourceFile);
@@ -2761,8 +2609,10 @@ var adoptCall = (edits, node, sourceFile, receiverName, fnName, slotName, slot =
     kind: "replace"
   });
 };
-var skippedComplexCall = (node, filePath) => {
-  if (isSvelteCompilerCall2(node, filePath) || isDirectSuperCall(node)) return false;
+var skippedComplexCall = (node, filePath, sourceFile, policy) => {
+  if (isPolicyCompilerCall(node, filePath, sourceFile, policy) || isDirectSuperCall(node)) {
+    return false;
+  }
   if (isSimpleProvenanceCall(node)) return false;
   if (!callCanCarryProvenance(node)) return false;
   return true;
@@ -2778,7 +2628,7 @@ var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(sourc
   let callWraps = 0;
   let provenanceSkippedComplexCall = 0;
   const visit = (node) => {
-    if (ts11.isCallExpression(node) && isSimpleProducerCall(node) && !isAwaitExpressionOf(node)) {
+    if (ts10.isCallExpression(node) && isSimpleProducerCall(node) && !isAwaitExpressionOf(node)) {
       edits.push({
         position: node.getStart(sourceFile),
         text: replaceProducerCall(node, sourceFile, receiverName),
@@ -2788,19 +2638,19 @@ var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(sourc
         kind: "replace"
       });
       callWraps += 1;
-    } else if (adoptCalls && ts11.isCallExpression(node) && shouldAdoptCall(node, filePath)) {
+    } else if (adoptCalls && ts10.isCallExpression(node) && shouldAdoptCall(node, filePath, sourceFile, options?.policy)) {
       adoptCall(edits, node, sourceFile, receiverName, adoptFnName, slotName);
       callWraps += 1;
-    } else if (ts11.isCallExpression(node) && !isAwaitExpressionOf(node) && isReturnedOrBoundCall(node) && skippedComplexCall(node, filePath)) {
+    } else if (ts10.isCallExpression(node) && !isAwaitExpressionOf(node) && isReturnedOrBoundCall(node) && skippedComplexCall(node, filePath, sourceFile, options?.policy)) {
       provenanceSkippedComplexCall += 1;
     }
-    if (ts11.isAwaitExpression(node)) {
+    if (ts10.isAwaitExpression(node)) {
       const inner = peel(node.expression);
-      const producer = ts11.isCallExpression(inner) && isSimpleProducerCall(inner);
-      const adoptInner = adoptCalls && ts11.isCallExpression(inner) && shouldAdoptAwaitCall(inner, filePath);
-      const adoptValue = adoptCalls && !ts11.isCallExpression(inner);
+      const producer = ts10.isCallExpression(inner) && isSimpleProducerCall(inner);
+      const adoptInner = adoptCalls && ts10.isCallExpression(inner) && shouldAdoptAwaitCall(inner, filePath, sourceFile, options?.policy);
+      const adoptValue = adoptCalls && !ts10.isCallExpression(inner);
       if (producer || adoptInner || adoptValue) {
-        if (producer && ts11.isCallExpression(inner)) {
+        if (producer && ts10.isCallExpression(inner)) {
           edits.push({
             position: node.expression.getStart(sourceFile),
             text: `(${slotName}={p:${replaceProducerCall(inner, sourceFile, receiverName)}},${slotName}.p)`,
@@ -2810,7 +2660,7 @@ var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(sourc
             kind: "replace"
           });
           callWraps += 1;
-        } else if (adoptInner && ts11.isCallExpression(inner)) {
+        } else if (adoptInner && ts10.isCallExpression(inner)) {
           if (node.expression === inner) {
             adoptCall(edits, inner, sourceFile, receiverName, adoptFnName, slotName, true);
           } else {
@@ -2846,11 +2696,11 @@ var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(sourc
         awaitWraps += 1;
         const body = owningFunctionBody(node);
         if (body) bodies.add(body);
-      } else if (ts11.isCallExpression(inner) && skippedComplexCall(inner, filePath)) {
+      } else if (ts10.isCallExpression(inner) && skippedComplexCall(inner, filePath, sourceFile, options?.policy)) {
         provenanceSkippedComplexCall += 1;
       }
     }
-    ts11.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(sourceFile);
   if (edits.length > 0) {
@@ -2877,7 +2727,7 @@ var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(sourc
 };
 
 // ../instrumentation/src/literal-sites.ts
-import ts12 from "typescript";
+import ts11 from "typescript";
 var STRUCT_CALLEE = "globalThis.__rasputinK";
 var owningFunction = (position, classifications) => {
   let owner;
@@ -2897,7 +2747,7 @@ var walkPeelParent = (node) => {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if ((ts12.isParenthesizedExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isSatisfiesExpression(parent)) && parent.expression === current) {
+    if ((ts11.isParenthesizedExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isSatisfiesExpression(parent)) && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -2909,13 +2759,13 @@ var isCapturePosition = (node) => {
   const current = walkPeelParent(node);
   const parent = current.parent;
   if (!parent) return false;
-  if (ts12.isReturnStatement(parent) && parent.expression === current) return true;
-  if (ts12.isArrowFunction(parent) && parent.body === current) return true;
-  if (ts12.isVariableDeclaration(parent) && parent.initializer === current) return true;
-  if (ts12.isBinaryExpression(parent) && parent.operatorToken.kind === ts12.SyntaxKind.EqualsToken && parent.right === current) {
+  if (ts11.isReturnStatement(parent) && parent.expression === current) return true;
+  if (ts11.isArrowFunction(parent) && parent.body === current) return true;
+  if (ts11.isVariableDeclaration(parent) && parent.initializer === current) return true;
+  if (ts11.isBinaryExpression(parent) && parent.operatorToken.kind === ts11.SyntaxKind.EqualsToken && parent.right === current) {
     return true;
   }
-  if (ts12.isCallExpression(parent) || ts12.isNewExpression(parent)) {
+  if (ts11.isCallExpression(parent) || ts11.isNewExpression(parent)) {
     return parent.arguments?.some((argument) => argument === current) === true;
   }
   return false;
@@ -2924,13 +2774,13 @@ var isInAssignmentPattern = (node) => {
   let current = walkPeelParent(node);
   while (current.parent) {
     const parent = current.parent;
-    if (ts12.isBinaryExpression(parent) && parent.operatorToken.kind === ts12.SyntaxKind.EqualsToken && parent.left === current) {
+    if (ts11.isBinaryExpression(parent) && parent.operatorToken.kind === ts11.SyntaxKind.EqualsToken && parent.left === current) {
       return true;
     }
-    if ((ts12.isForOfStatement(parent) || ts12.isForInStatement(parent)) && parent.initializer === current) {
+    if ((ts11.isForOfStatement(parent) || ts11.isForInStatement(parent)) && parent.initializer === current) {
       return true;
     }
-    if (ts12.isPropertyAssignment(parent) || ts12.isShorthandPropertyAssignment(parent) || ts12.isSpreadAssignment(parent) || ts12.isObjectLiteralExpression(parent) || ts12.isArrayLiteralExpression(parent) || ts12.isParenthesizedExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isSatisfiesExpression(parent)) {
+    if (ts11.isPropertyAssignment(parent) || ts11.isShorthandPropertyAssignment(parent) || ts11.isSpreadAssignment(parent) || ts11.isObjectLiteralExpression(parent) || ts11.isArrayLiteralExpression(parent) || ts11.isParenthesizedExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isSatisfiesExpression(parent)) {
       current = walkPeelParent(parent);
       continue;
     }
@@ -2942,8 +2792,8 @@ var isLiteralChild = (node) => {
   const current = walkPeelParent(node);
   const parent = current.parent;
   if (!parent) return false;
-  if (ts12.isPropertyAssignment(parent) && parent.initializer === current) return true;
-  if (ts12.isArrayLiteralExpression(parent)) return true;
+  if (ts11.isPropertyAssignment(parent) && parent.initializer === current) return true;
+  if (ts11.isArrayLiteralExpression(parent)) return true;
   return false;
 };
 var shouldRewrite = (node, classifications, sourceFile) => {
@@ -2955,10 +2805,10 @@ var shouldRewrite = (node, classifications, sourceFile) => {
 var collectLiteralSiteEdits = (source, filePath, options, sourceFile = parseSource(source, filePath)) => {
   const edits = [];
   const visit = (node) => {
-    if ((ts12.isObjectLiteralExpression(node) || ts12.isArrayLiteralExpression(node)) && shouldRewrite(node, options.classifications, sourceFile)) {
+    if ((ts11.isObjectLiteralExpression(node) || ts11.isArrayLiteralExpression(node)) && shouldRewrite(node, options.classifications, sourceFile)) {
       wrap(edits, node.getStart(sourceFile), node.end, `${STRUCT_CALLEE}(`, ")", 15);
     }
-    ts12.forEachChild(node, visit);
+    ts11.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { edits };
@@ -2967,64 +2817,64 @@ var collectLiteralSiteEdits = (source, filePath, options, sourceFile = parseSour
 // ../instrumentation/src/observe-sites.ts
 import { createHash as createHash2 } from "node:crypto";
 import { resolve as resolve4 } from "node:path";
-import ts13 from "typescript";
+import ts12 from "typescript";
 var OBSERVE_CALLEE = "globalThis.__rasputinO";
 var siteIdFor = (filePath, line, column, text) => {
   const digest = createHash2("sha256").update(`${resolve4(filePath)}:${line}:${column}:${text}`).digest("base64url").slice(0, 16);
   return `rs_${digest}`;
 };
-var isAssignmentOperator = (kind) => kind === ts13.SyntaxKind.EqualsToken || kind === ts13.SyntaxKind.PlusEqualsToken || kind === ts13.SyntaxKind.MinusEqualsToken || kind === ts13.SyntaxKind.AsteriskEqualsToken || kind === ts13.SyntaxKind.SlashEqualsToken || kind === ts13.SyntaxKind.PercentEqualsToken || kind === ts13.SyntaxKind.AmpersandEqualsToken || kind === ts13.SyntaxKind.BarEqualsToken || kind === ts13.SyntaxKind.CaretEqualsToken || kind === ts13.SyntaxKind.LessThanLessThanEqualsToken || kind === ts13.SyntaxKind.GreaterThanGreaterThanEqualsToken || kind === ts13.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || kind === ts13.SyntaxKind.AsteriskAsteriskEqualsToken || kind === ts13.SyntaxKind.BarBarEqualsToken || kind === ts13.SyntaxKind.AmpersandAmpersandEqualsToken || kind === ts13.SyntaxKind.QuestionQuestionEqualsToken;
+var isAssignmentOperator = (kind) => kind === ts12.SyntaxKind.EqualsToken || kind === ts12.SyntaxKind.PlusEqualsToken || kind === ts12.SyntaxKind.MinusEqualsToken || kind === ts12.SyntaxKind.AsteriskEqualsToken || kind === ts12.SyntaxKind.SlashEqualsToken || kind === ts12.SyntaxKind.PercentEqualsToken || kind === ts12.SyntaxKind.AmpersandEqualsToken || kind === ts12.SyntaxKind.BarEqualsToken || kind === ts12.SyntaxKind.CaretEqualsToken || kind === ts12.SyntaxKind.LessThanLessThanEqualsToken || kind === ts12.SyntaxKind.GreaterThanGreaterThanEqualsToken || kind === ts12.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || kind === ts12.SyntaxKind.AsteriskAsteriskEqualsToken || kind === ts12.SyntaxKind.BarBarEqualsToken || kind === ts12.SyntaxKind.AmpersandAmpersandEqualsToken || kind === ts12.SyntaxKind.QuestionQuestionEqualsToken;
 var isSafeLiteral = (expression) => {
   const node = peel(expression);
-  if (ts13.isStringLiteral(node) || ts13.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts13.isNumericLiteral(node)) return true;
-  if (node.kind === ts13.SyntaxKind.TrueKeyword || node.kind === ts13.SyntaxKind.FalseKeyword || node.kind === ts13.SyntaxKind.NullKeyword) {
+  if (ts12.isStringLiteral(node) || ts12.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts12.isNumericLiteral(node)) return true;
+  if (node.kind === ts12.SyntaxKind.TrueKeyword || node.kind === ts12.SyntaxKind.FalseKeyword || node.kind === ts12.SyntaxKind.NullKeyword) {
     return true;
   }
-  if (ts13.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
-  if (ts13.isPrefixUnaryExpression(node) && node.operator === ts13.SyntaxKind.MinusToken && ts13.isNumericLiteral(node.operand)) {
+  if (ts12.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
+  if (ts12.isPrefixUnaryExpression(node) && node.operator === ts12.SyntaxKind.MinusToken && ts12.isNumericLiteral(node.operand)) {
     return true;
   }
-  return ts13.isVoidExpression(node) && ts13.isNumericLiteral(peel(node.expression)) && peel(node.expression).getText() === "0";
+  return ts12.isVoidExpression(node) && ts12.isNumericLiteral(peel(node.expression)) && peel(node.expression).getText() === "0";
 };
 var isPropertyRead = (node) => {
-  if (ts13.isPropertyAccessExpression(node)) {
-    return !ts13.isPrivateIdentifier(node.name) && node.expression.kind !== ts13.SyntaxKind.SuperKeyword;
+  if (ts12.isPropertyAccessExpression(node)) {
+    return !ts12.isPrivateIdentifier(node.name) && node.expression.kind !== ts12.SyntaxKind.SuperKeyword;
   }
-  if (ts13.isElementAccessExpression(node)) {
-    return node.expression.kind !== ts13.SyntaxKind.SuperKeyword;
+  if (ts12.isElementAccessExpression(node)) {
+    return node.expression.kind !== ts12.SyntaxKind.SuperKeyword;
   }
   return false;
 };
 var isMetaChain = (node) => {
-  if (ts13.isMetaProperty(node)) return true;
-  if (ts13.isPropertyAccessExpression(node)) return isMetaChain(node.expression);
-  if (ts13.isElementAccessExpression(node)) return isMetaChain(node.expression);
+  if (ts12.isMetaProperty(node)) return true;
+  if (ts12.isPropertyAccessExpression(node)) return isMetaChain(node.expression);
+  if (ts12.isElementAccessExpression(node)) return isMetaChain(node.expression);
   return false;
 };
 var isPatternParent = (parent, child) => {
-  if (ts13.isParenthesizedExpression(parent) && parent.expression === child) return true;
-  if (ts13.isAsExpression(parent) && parent.expression === child) return true;
-  if (ts13.isTypeAssertionExpression(parent) && parent.expression === child) return true;
-  if (ts13.isNonNullExpression(parent) && parent.expression === child) return true;
-  if (ts13.isSatisfiesExpression(parent) && parent.expression === child) return true;
-  if (ts13.isPropertyAssignment(parent) && parent.initializer === child) return true;
-  if (ts13.isShorthandPropertyAssignment(parent)) return true;
-  if (ts13.isSpreadAssignment(parent) && parent.expression === child) return true;
-  if (ts13.isSpreadElement(parent) && parent.expression === child) return true;
-  if (ts13.isArrayLiteralExpression(parent)) return true;
-  if (ts13.isObjectLiteralExpression(parent)) return true;
+  if (ts12.isParenthesizedExpression(parent) && parent.expression === child) return true;
+  if (ts12.isAsExpression(parent) && parent.expression === child) return true;
+  if (ts12.isTypeAssertionExpression(parent) && parent.expression === child) return true;
+  if (ts12.isNonNullExpression(parent) && parent.expression === child) return true;
+  if (ts12.isSatisfiesExpression(parent) && parent.expression === child) return true;
+  if (ts12.isPropertyAssignment(parent) && parent.initializer === child) return true;
+  if (ts12.isShorthandPropertyAssignment(parent)) return true;
+  if (ts12.isSpreadAssignment(parent) && parent.expression === child) return true;
+  if (ts12.isSpreadElement(parent) && parent.expression === child) return true;
+  if (ts12.isArrayLiteralExpression(parent)) return true;
+  if (ts12.isObjectLiteralExpression(parent)) return true;
   return false;
 };
 var isAssignmentTarget = (node) => {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if (ts13.isComputedPropertyName(parent) && parent.expression === current) return false;
-    if (ts13.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
+    if (ts12.isComputedPropertyName(parent) && parent.expression === current) return false;
+    if (ts12.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
       return parent.left === current;
     }
-    if ((ts13.isForOfStatement(parent) || ts13.isForInStatement(parent)) && parent.initializer === current) {
+    if ((ts12.isForOfStatement(parent) || ts12.isForInStatement(parent)) && parent.initializer === current) {
       return true;
     }
     if (!isPatternParent(parent, current)) return false;
@@ -3036,18 +2886,18 @@ var isValueContext = (node) => {
   if (isAssignmentTarget(node)) return false;
   const parent = node.parent;
   if (!parent) return false;
-  if (ts13.isVariableDeclaration(parent) && parent.initializer === node) return true;
-  if (ts13.isReturnStatement(parent) && parent.expression === node) return true;
-  if (ts13.isPropertyAssignment(parent) && parent.initializer === node) return true;
-  if (ts13.isParenthesizedExpression(parent) || ts13.isNonNullExpression(parent) || ts13.isAsExpression(parent) || ts13.isTypeAssertionExpression(parent) || ts13.isSatisfiesExpression(parent)) {
+  if (ts12.isVariableDeclaration(parent) && parent.initializer === node) return true;
+  if (ts12.isReturnStatement(parent) && parent.expression === node) return true;
+  if (ts12.isPropertyAssignment(parent) && parent.initializer === node) return true;
+  if (ts12.isParenthesizedExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isSatisfiesExpression(parent)) {
     return isValueContext(parent);
   }
   return false;
 };
 var isCoalesceWithLiteral = (node) => {
-  if (!ts13.isBinaryExpression(node)) return false;
+  if (!ts12.isBinaryExpression(node)) return false;
   const operator = node.operatorToken.kind;
-  if (operator !== ts13.SyntaxKind.QuestionQuestionToken && operator !== ts13.SyntaxKind.BarBarToken) {
+  if (operator !== ts12.SyntaxKind.QuestionQuestionToken && operator !== ts12.SyntaxKind.BarBarToken) {
     return false;
   }
   return isSafeLiteral(node.right);
@@ -3056,19 +2906,19 @@ var shouldWrapPropertyRead = (node) => {
   if (isMetaChain(node)) return false;
   const parent = node.parent;
   if (!parent) return false;
-  if (ts13.isPropertyAccessExpression(parent) && parent.expression === node) return false;
-  if (ts13.isElementAccessExpression(parent) && parent.expression === node) return false;
-  if (ts13.isCallExpression(parent) && parent.expression === node) return false;
-  if (ts13.isNewExpression(parent) && parent.expression === node) return false;
-  if (ts13.isTaggedTemplateExpression(parent) && parent.tag === node) return false;
-  if (ts13.isDeleteExpression(parent)) return false;
-  if (ts13.isPrefixUnaryExpression(parent) && (parent.operator === ts13.SyntaxKind.PlusPlusToken || parent.operator === ts13.SyntaxKind.MinusMinusToken)) {
+  if (ts12.isPropertyAccessExpression(parent) && parent.expression === node) return false;
+  if (ts12.isElementAccessExpression(parent) && parent.expression === node) return false;
+  if (ts12.isCallExpression(parent) && parent.expression === node) return false;
+  if (ts12.isNewExpression(parent) && parent.expression === node) return false;
+  if (ts12.isTaggedTemplateExpression(parent) && parent.tag === node) return false;
+  if (ts12.isDeleteExpression(parent)) return false;
+  if (ts12.isPrefixUnaryExpression(parent) && (parent.operator === ts12.SyntaxKind.PlusPlusToken || parent.operator === ts12.SyntaxKind.MinusMinusToken)) {
     return false;
   }
-  if (ts13.isPostfixUnaryExpression(parent) && (parent.operator === ts13.SyntaxKind.PlusPlusToken || parent.operator === ts13.SyntaxKind.MinusMinusToken)) {
+  if (ts12.isPostfixUnaryExpression(parent) && (parent.operator === ts12.SyntaxKind.PlusPlusToken || parent.operator === ts12.SyntaxKind.MinusMinusToken)) {
     return false;
   }
-  if (ts13.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
+  if (ts12.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
     if (parent.left === node) return false;
   }
   if (isValueContext(node)) return true;
@@ -3083,15 +2933,15 @@ var shouldWrapRead = (node, classifications, sourceFile) => {
 };
 var hasOptional = (node) => !!node.questionDotToken;
 var isInternalProperty = (node) => {
-  if (ts13.isPropertyAccessExpression(node)) return node.name.text.startsWith("__");
-  if (!ts13.isStringLiteral(node.argumentExpression) && !ts13.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
+  if (ts12.isPropertyAccessExpression(node)) return node.name.text.startsWith("__");
+  if (!ts12.isStringLiteral(node.argumentExpression) && !ts12.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
     return false;
   }
   return node.argumentExpression.text.startsWith("__");
 };
 var staticPropertyName = (node) => {
-  if (ts13.isPropertyAccessExpression(node)) return node.name.text;
-  if (ts13.isStringLiteral(node.argumentExpression) || ts13.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
+  if (ts12.isPropertyAccessExpression(node)) return node.name.text;
+  if (ts12.isStringLiteral(node.argumentExpression) || ts12.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
     return node.argumentExpression.text;
   }
   return void 0;
@@ -3110,21 +2960,21 @@ var isSensitiveRead = (node) => {
   if (name === void 0) return false;
   return propertyNameIsSensitive(name) || BROWSER_SENSITIVE_SURFACES.has(name);
 };
-var allowsExpressionCapture = (owner) => owner.captureClass === "full" || owner.captureClass === "reactive-sparse" || owner.captureReason === "svelte component wrapper";
+var allowsExpressionCapture = (owner) => owner.captureClass === "full" || owner.captureClass === "reactive-sparse" || owner.compilerRole === "component-wrapper";
 var isReactiveArrowValue = (node, classifications, sourceFile) => {
   let current = node;
   while (current) {
     const parent = current.parent;
     if (!parent) return false;
-    if (ts13.isArrowFunction(parent) && parent.body === current) {
+    if (ts12.isArrowFunction(parent) && parent.body === current) {
       const owner = owningFunction2(node.getStart(sourceFile), classifications);
       return owner?.captureClass === "reactive-sparse";
     }
-    if (ts13.isBinaryExpression(parent) && (parent.left === current || parent.right === current) && !isAssignmentOperator(parent.operatorToken.kind)) {
+    if (ts12.isBinaryExpression(parent) && (parent.left === current || parent.right === current) && !isAssignmentOperator(parent.operatorToken.kind)) {
       current = parent;
       continue;
     }
-    if (ts13.isParenthesizedExpression(parent) || ts13.isNonNullExpression(parent) || ts13.isAsExpression(parent) || ts13.isTypeAssertionExpression(parent) || ts13.isSatisfiesExpression(parent)) {
+    if (ts12.isParenthesizedExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isSatisfiesExpression(parent)) {
       current = parent;
       continue;
     }
@@ -3155,7 +3005,7 @@ var collectObserveSiteEdits = (source, filePath, options = {}, sourceFile = pars
       if (options.classifications) {
         const owner = owningFunction2(node.getStart(sourceFile), options.classifications);
         if (!owner || !allowsExpressionCapture(owner)) {
-          ts13.forEachChild(node, visit);
+          ts12.forEachChild(node, visit);
           return;
         }
       }
@@ -3180,7 +3030,7 @@ var collectObserveSiteEdits = (source, filePath, options = {}, sourceFile = pars
         }
       });
     }
-    ts13.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
   visit(sourceFile);
   queued.sort((left, right) => right.start - left.start);
@@ -3212,8 +3062,14 @@ var collectObserveSiteEdits = (source, filePath, options = {}, sourceFile = pars
   return { edits, sites: applied };
 };
 
+// ../instrumentation/src/svelte-module-path.ts
+var isSvelteCompiledPath = (idOrPath) => {
+  const path = idOrPath.split("?")[0]?.replaceAll("\\", "/") ?? "";
+  return path.endsWith(".svelte") || path.endsWith(".svelte.ts") || path.endsWith(".svelte.js");
+};
+
 // ../instrumentation/src/verify-browser-source.ts
-import ts14 from "typescript";
+import ts13 from "typescript";
 var RASPUTIN_IDENT = /^__rasputin/;
 var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
   "__rasputinO",
@@ -3230,13 +3086,13 @@ var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
 ]);
 var isRasputinName = (name) => RASPUTIN_IDENT.test(name);
 var identText = (node) => {
-  if (ts14.isIdentifier(node)) return node.text;
-  if (ts14.isPrivateIdentifier(node)) return node.text;
+  if (ts13.isIdentifier(node)) return node.text;
+  if (ts13.isPrivateIdentifier(node)) return node.text;
   return void 0;
 };
 var calleeName = (expression) => {
-  if (ts14.isIdentifier(expression)) return expression.text;
-  if (ts14.isPropertyAccessExpression(expression)) {
+  if (ts13.isIdentifier(expression)) return expression.text;
+  if (ts13.isPropertyAccessExpression(expression)) {
     const object = identText(expression.expression);
     const property = identText(expression.name);
     if (object && isRasputinName(object) && property) return `${object}.${property}`;
@@ -3245,17 +3101,17 @@ var calleeName = (expression) => {
   return void 0;
 };
 var isRasputinCall = (node) => {
-  if (!ts14.isCallExpression(node)) return false;
+  if (!ts13.isCallExpression(node)) return false;
   const name = calleeName(node.expression);
   return Boolean(name && (isRasputinName(name) || BROWSER_GLOBALS.has(name)));
 };
 var isRasputinAssignment = (node) => {
-  if (!ts14.isBinaryExpression(node)) return false;
+  if (!ts13.isBinaryExpression(node)) return false;
   const operator = node.operatorToken.kind;
-  if (operator !== ts14.SyntaxKind.EqualsToken && operator !== ts14.SyntaxKind.QuestionQuestionEqualsToken) {
+  if (operator !== ts13.SyntaxKind.EqualsToken && operator !== ts13.SyntaxKind.QuestionQuestionEqualsToken) {
     return false;
   }
-  if (ts14.isPropertyAccessExpression(node.left)) {
+  if (ts13.isPropertyAccessExpression(node.left)) {
     const object = identText(node.left.expression);
     const property = identText(node.left.name);
     return object === "globalThis" && property !== void 0 && BROWSER_GLOBALS.has(property);
@@ -3267,28 +3123,28 @@ var isRasputinOnlyInitializer = (expression) => {
   if (!expression) return true;
   const unwrapped = unwrapCall(expression);
   if (unwrapped !== expression) {
-    return ts14.isExpression(unwrapped) ? isRasputinOnlyInitializer(unwrapped) : false;
+    return ts13.isExpression(unwrapped) ? isRasputinOnlyInitializer(unwrapped) : false;
   }
   return isRasputinCall(expression);
 };
 var jsonAwaitSlot = (node) => {
-  if (node.operatorToken.kind !== ts14.SyntaxKind.CommaToken) return void 0;
+  if (node.operatorToken.kind !== ts13.SyntaxKind.CommaToken) return void 0;
   const assigned = node.left;
-  if (!ts14.isBinaryExpression(assigned) || assigned.operatorToken.kind !== ts14.SyntaxKind.EqualsToken || !ts14.isIdentifier(assigned.left) || !isRasputinName(assigned.left.text) || !ts14.isObjectLiteralExpression(assigned.right)) {
+  if (!ts13.isBinaryExpression(assigned) || assigned.operatorToken.kind !== ts13.SyntaxKind.EqualsToken || !ts13.isIdentifier(assigned.left) || !isRasputinName(assigned.left.text) || !ts13.isObjectLiteralExpression(assigned.right)) {
     return void 0;
   }
   const property = assigned.right.properties[0];
-  if (!property || !ts14.isPropertyAssignment(property) || !ts14.isIdentifier(property.name) || property.name.text !== "p") {
+  if (!property || !ts13.isPropertyAssignment(property) || !ts13.isIdentifier(property.name) || property.name.text !== "p") {
     return void 0;
   }
-  if (!ts14.isPropertyAccessExpression(node.right) || !ts14.isIdentifier(node.right.expression) || !isRasputinName(node.right.expression.text) || node.right.name.text !== "p") {
+  if (!ts13.isPropertyAccessExpression(node.right) || !ts13.isIdentifier(node.right.expression) || !isRasputinName(node.right.expression.text) || node.right.name.text !== "p") {
     return void 0;
   }
   return property.initializer;
 };
 var peelParens = (node) => {
   let current = node;
-  while (ts14.isParenthesizedExpression(current)) current = current.expression;
+  while (ts13.isParenthesizedExpression(current)) current = current.expression;
   return current;
 };
 var jsonMethodCall = (node) => {
@@ -3296,9 +3152,9 @@ var jsonMethodCall = (node) => {
   const fn = node.arguments[1];
   if (!receiver || !fn) return void 0;
   const args = node.arguments.slice(2);
-  if (!ts14.isPropertyAccessExpression(fn)) return void 0;
-  return ts14.factory.createCallExpression(
-    ts14.factory.createPropertyAccessExpression(receiver, fn.name),
+  if (!ts13.isPropertyAccessExpression(fn)) return void 0;
+  return ts13.factory.createCallExpression(
+    ts13.factory.createPropertyAccessExpression(receiver, fn.name),
     void 0,
     args
   );
@@ -3308,55 +3164,55 @@ var unwrapAdoptIife = (node) => {
   const adopted = node.arguments[0];
   if (!adopted) return void 0;
   const callee = peelParens(node.expression);
-  if (!ts14.isArrowFunction(callee) || callee.parameters.length !== 1 || ts14.isBlock(callee.body)) {
+  if (!ts13.isArrowFunction(callee) || callee.parameters.length !== 1 || ts13.isBlock(callee.body)) {
     return void 0;
   }
   const param = callee.parameters[0];
-  if (!param || !ts14.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
+  if (!param || !ts13.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
     return void 0;
   }
   const body = peelParens(callee.body);
-  if (ts14.isCallExpression(body) && calleeName(body.expression) === "__rasputinP") {
+  if (ts13.isCallExpression(body) && calleeName(body.expression) === "__rasputinP") {
     const invoked = body.arguments[0];
-    if (invoked && ts14.isCallExpression(invoked) && ts14.isIdentifier(invoked.expression) && invoked.expression.text === param.name.text) {
-      return ts14.factory.createCallExpression(adopted, void 0, invoked.arguments);
+    if (invoked && ts13.isCallExpression(invoked) && ts13.isIdentifier(invoked.expression) && invoked.expression.text === param.name.text) {
+      return ts13.factory.createCallExpression(adopted, void 0, invoked.arguments);
     }
     return void 0;
   }
-  if (!ts14.isCallExpression(body) || body.arguments.length !== 1) return void 0;
+  if (!ts13.isCallExpression(body) || body.arguments.length !== 1) return void 0;
   const methodLookup = body.arguments[0];
   if (!methodLookup) return void 0;
   const inner = peelParens(body.expression);
-  if (!ts14.isArrowFunction(inner) || inner.parameters.length !== 1 || ts14.isBlock(inner.body)) {
+  if (!ts13.isArrowFunction(inner) || inner.parameters.length !== 1 || ts13.isBlock(inner.body)) {
     return void 0;
   }
   const fnParam = inner.parameters[0];
-  if (!fnParam || !ts14.isIdentifier(fnParam.name) || fnParam.dotDotDotToken || fnParam.initializer) {
+  if (!fnParam || !ts13.isIdentifier(fnParam.name) || fnParam.dotDotDotToken || fnParam.initializer) {
     return void 0;
   }
   const innerBody = peelParens(inner.body);
-  if (!ts14.isCallExpression(innerBody) || calleeName(innerBody.expression) !== "__rasputinP") {
+  if (!ts13.isCallExpression(innerBody) || calleeName(innerBody.expression) !== "__rasputinP") {
     return void 0;
   }
   const applied = innerBody.arguments[0];
-  if (!applied || !ts14.isCallExpression(applied)) return void 0;
+  if (!applied || !ts13.isCallExpression(applied)) return void 0;
   const applyCallee = peelParens(applied.expression);
-  if (!ts14.isPropertyAccessExpression(applyCallee) || applyCallee.name.text !== "apply" || !ts14.isIdentifier(applyCallee.expression) || applyCallee.expression.text !== "Reflect") {
+  if (!ts13.isPropertyAccessExpression(applyCallee) || applyCallee.name.text !== "apply" || !ts13.isIdentifier(applyCallee.expression) || applyCallee.expression.text !== "Reflect") {
     return void 0;
   }
   const appliedFn = applied.arguments[0];
   const thisArg = applied.arguments[1];
   const argsArg = applied.arguments[2];
-  if (!appliedFn || !ts14.isIdentifier(appliedFn) || appliedFn.text !== fnParam.name.text) {
+  if (!appliedFn || !ts13.isIdentifier(appliedFn) || appliedFn.text !== fnParam.name.text) {
     return void 0;
   }
-  if (!thisArg || !ts14.isIdentifier(thisArg) || thisArg.text !== param.name.text) return void 0;
-  if (!argsArg || !ts14.isArrayLiteralExpression(argsArg)) return void 0;
-  if (!ts14.isPropertyAccessExpression(methodLookup) || !ts14.isIdentifier(methodLookup.expression) || methodLookup.expression.text !== param.name.text || ts14.isPrivateIdentifier(methodLookup.name)) {
+  if (!thisArg || !ts13.isIdentifier(thisArg) || thisArg.text !== param.name.text) return void 0;
+  if (!argsArg || !ts13.isArrayLiteralExpression(argsArg)) return void 0;
+  if (!ts13.isPropertyAccessExpression(methodLookup) || !ts13.isIdentifier(methodLookup.expression) || methodLookup.expression.text !== param.name.text || ts13.isPrivateIdentifier(methodLookup.name)) {
     return void 0;
   }
-  return ts14.factory.createCallExpression(
-    ts14.factory.createPropertyAccessExpression(adopted, methodLookup.name),
+  return ts13.factory.createCallExpression(
+    ts13.factory.createPropertyAccessExpression(adopted, methodLookup.name),
     void 0,
     [...argsArg.elements]
   );
@@ -3366,23 +3222,23 @@ var unwrapProducerIife = (node) => {
   const receiver = node.arguments[0];
   if (!receiver) return void 0;
   const callee = peelParens(node.expression);
-  if (!ts14.isArrowFunction(callee) || callee.parameters.length !== 1 || ts14.isBlock(callee.body)) {
+  if (!ts13.isArrowFunction(callee) || callee.parameters.length !== 1 || ts13.isBlock(callee.body)) {
     return void 0;
   }
   const param = callee.parameters[0];
-  if (!param || !ts14.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
+  if (!param || !ts13.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
     return void 0;
   }
   const body = peelParens(callee.body);
-  if (!ts14.isCallExpression(body) || !isRasputinCall(body)) return void 0;
+  if (!ts13.isCallExpression(body) || !isRasputinCall(body)) return void 0;
   if (calleeName(body.expression) !== "__rasputinM") return void 0;
   const bound = body.arguments[0];
   const fn = body.arguments[1];
-  if (!bound || !fn || !ts14.isIdentifier(bound) || bound.text !== param.name.text) return void 0;
-  if (!ts14.isPropertyAccessExpression(fn)) return void 0;
-  if (!ts14.isIdentifier(fn.expression) || fn.expression.text !== param.name.text) return void 0;
-  return ts14.factory.createCallExpression(
-    ts14.factory.createPropertyAccessExpression(receiver, fn.name),
+  if (!bound || !fn || !ts13.isIdentifier(bound) || bound.text !== param.name.text) return void 0;
+  if (!ts13.isPropertyAccessExpression(fn)) return void 0;
+  if (!ts13.isIdentifier(fn.expression) || fn.expression.text !== param.name.text) return void 0;
+  return ts13.factory.createCallExpression(
+    ts13.factory.createPropertyAccessExpression(receiver, fn.name),
     void 0,
     body.arguments.slice(2)
   );
@@ -3390,22 +3246,22 @@ var unwrapProducerIife = (node) => {
 var unwrapCall = (node) => {
   let current = node;
   while (true) {
-    if (ts14.isParenthesizedExpression(current)) {
+    if (ts13.isParenthesizedExpression(current)) {
       current = current.expression;
       continue;
     }
-    if (ts14.isBinaryExpression(current)) {
+    if (ts13.isBinaryExpression(current)) {
       const slot = jsonAwaitSlot(current);
       if (slot) {
         current = slot;
         continue;
       }
     }
-    if (ts14.isConditionalExpression(current) && isRasputinName(identText(current.condition) ?? "")) {
+    if (ts13.isConditionalExpression(current) && isRasputinName(identText(current.condition) ?? "")) {
       current = current.whenTrue;
       continue;
     }
-    if (ts14.isCallExpression(current)) {
+    if (ts13.isCallExpression(current)) {
       const adopted = unwrapAdoptIife(current);
       if (adopted) {
         current = adopted;
@@ -3417,7 +3273,7 @@ var unwrapCall = (node) => {
         continue;
       }
     }
-    if (ts14.isCallExpression(current) && isRasputinCall(current)) {
+    if (ts13.isCallExpression(current) && isRasputinCall(current)) {
       const name = calleeName(current.expression);
       if ((name === "__rasputinO" || name === "__rasputinL") && current.arguments.length >= 2 && current.arguments[1]) {
         current = current.arguments[1];
@@ -3450,26 +3306,26 @@ var unwrapCall = (node) => {
 var isRasputinIf = (node) => {
   if (node.elseStatement) return false;
   const condition = node.expression;
-  const negated = ts14.isPrefixUnaryExpression(condition) && condition.operator === ts14.SyntaxKind.ExclamationToken && isRasputinName(identText(condition.operand) ?? "");
+  const negated = ts13.isPrefixUnaryExpression(condition) && condition.operator === ts13.SyntaxKind.ExclamationToken && isRasputinName(identText(condition.operand) ?? "");
   if (!negated) return false;
   const then = node.thenStatement;
-  if (ts14.isExpressionStatement(then) && isRasputinCall(then.expression)) return true;
-  return ts14.isBlock(then) && then.statements.every((statement) => isRasputinStatement(statement));
+  if (ts13.isExpressionStatement(then) && isRasputinCall(then.expression)) return true;
+  return ts13.isBlock(then) && then.statements.every((statement) => isRasputinStatement(statement));
 };
 var isRasputinStatement = (node) => {
-  if (ts14.isEmptyStatement(node)) return true;
-  if (ts14.isVariableStatement(node)) {
+  if (ts13.isEmptyStatement(node)) return true;
+  if (ts13.isVariableStatement(node)) {
     return node.declarationList.declarations.every((declaration) => {
       const name = identText(declaration.name);
       return Boolean(name && isRasputinName(name));
     });
   }
-  if (ts14.isExpressionStatement(node)) {
+  if (ts13.isExpressionStatement(node)) {
     if (isRasputinAssignment(node.expression)) return true;
     if (!isRasputinCall(node.expression)) return false;
     return unwrapCall(node.expression) === node.expression;
   }
-  if (ts14.isIfStatement(node)) return isRasputinIf(node);
+  if (ts13.isIfStatement(node)) return isRasputinIf(node);
   return false;
 };
 var isRasputinTryWrapper = (node) => {
@@ -3479,12 +3335,12 @@ var isRasputinTryWrapper = (node) => {
     (statement) => !isRasputinStatement(statement)
   );
   const leftover = catchCalls[0];
-  const leftoverThrow = catchCalls.length === 1 && leftover !== void 0 && ts14.isThrowStatement(leftover) && ts14.isIdentifier(leftover.expression);
+  const leftoverThrow = catchCalls.length === 1 && leftover !== void 0 && ts13.isThrowStatement(leftover) && ts13.isIdentifier(leftover.expression);
   if (!leftoverThrow && catchCalls.length > 0) return false;
   return node.finallyBlock.statements.every((statement) => isRasputinStatement(statement));
 };
 var customerTempInit = (statement) => {
-  if (!ts14.isVariableStatement(statement)) return void 0;
+  if (!ts13.isVariableStatement(statement)) return void 0;
   for (const declaration of statement.declarationList.declarations) {
     const name = identText(declaration.name);
     if (!name || !isRasputinName(name) || !declaration.initializer) continue;
@@ -3497,7 +3353,7 @@ var flattenStatements = (statements) => {
   const flattened = [];
   for (const statement of statements) {
     if (isRasputinStatement(statement)) continue;
-    if (ts14.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
+    if (ts13.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
       flattened.push(...flattenStatements(statement.tryBlock.statements));
       continue;
     }
@@ -3506,27 +3362,27 @@ var flattenStatements = (statements) => {
   return flattened;
 };
 var isRememberIife = (node) => {
-  if (!ts14.isCallExpression(node) || node.arguments.length > 0) return void 0;
+  if (!ts13.isCallExpression(node) || node.arguments.length > 0) return void 0;
   let callee = node.expression;
-  if (ts14.isParenthesizedExpression(callee)) callee = callee.expression;
-  if (!ts14.isArrowFunction(callee) || callee.parameters.length > 0 || !ts14.isBlock(callee.body)) {
+  if (ts13.isParenthesizedExpression(callee)) callee = callee.expression;
+  if (!ts13.isArrowFunction(callee) || callee.parameters.length > 0 || !ts13.isBlock(callee.body)) {
     return void 0;
   }
   const statements = callee.body.statements;
   const last = statements.at(-1);
-  if (!last || !ts14.isReturnStatement(last) || !last.expression) return void 0;
+  if (!last || !ts13.isReturnStatement(last) || !last.expression) return void 0;
   let returned = last.expression;
-  while (ts14.isParenthesizedExpression(returned)) returned = returned.expression;
-  if (!ts14.isCallExpression(returned)) return void 0;
+  while (ts13.isParenthesizedExpression(returned)) returned = returned.expression;
+  if (!ts13.isCallExpression(returned)) return void 0;
   const name = calleeName(returned.expression);
   if (name !== "__rasputinK") return void 0;
   const objectArg = returned.arguments[0];
-  if (!objectArg || !ts14.isIdentifier(objectArg)) return void 0;
+  if (!objectArg || !ts13.isIdentifier(objectArg)) return void 0;
   const temps = /* @__PURE__ */ new Map();
   for (const statement of statements.slice(0, -1)) {
-    if (!ts14.isVariableStatement(statement)) return void 0;
+    if (!ts13.isVariableStatement(statement)) return void 0;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts14.isIdentifier(declaration.name) || !declaration.initializer) return void 0;
+      if (!ts13.isIdentifier(declaration.name) || !declaration.initializer) return void 0;
       temps.set(declaration.name.text, declaration.initializer);
     }
   }
@@ -3536,10 +3392,10 @@ var isRememberIife = (node) => {
 };
 var resolveRememberTemp = (expression, temps, seen) => {
   let current = expression;
-  while (ts14.isParenthesizedExpression(current) || ts14.isNonNullExpression(current) || ts14.isAsExpression(current) || ts14.isTypeAssertionExpression(current) || ts14.isSatisfiesExpression(current)) {
+  while (ts13.isParenthesizedExpression(current) || ts13.isNonNullExpression(current) || ts13.isAsExpression(current) || ts13.isTypeAssertionExpression(current) || ts13.isSatisfiesExpression(current)) {
     current = current.expression;
   }
-  if (ts14.isIdentifier(current) && temps.has(current.text) && !seen.has(current.text)) {
+  if (ts13.isIdentifier(current) && temps.has(current.text) && !seen.has(current.text)) {
     const next = temps.get(current.text);
     if (!next) return current;
     seen.add(current.text);
@@ -3548,27 +3404,27 @@ var resolveRememberTemp = (expression, temps, seen) => {
   return current;
 };
 var extra = (node) => {
-  if (ts14.isIdentifier(node) || ts14.isPrivateIdentifier(node)) {
+  if (ts13.isIdentifier(node) || ts13.isPrivateIdentifier(node)) {
     return isRasputinName(node.text) ? "" : node.text;
   }
-  if (ts14.isStringLiteral(node) || ts14.isNumericLiteral(node) || ts14.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts13.isStringLiteral(node) || ts13.isNumericLiteral(node) || ts13.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
-  if (ts14.isToken(node) && !ts14.isIdentifier(node)) return ts14.SyntaxKind[node.kind] ?? "";
+  if (ts13.isToken(node) && !ts13.isIdentifier(node)) return ts13.SyntaxKind[node.kind] ?? "";
   return "";
 };
 var signatureOfSubstituted = (node, temps) => {
   const remembered = isRememberIife(node);
   if (remembered) return signatureOfSubstituted(remembered.object, remembered.temps);
-  if (ts14.isObjectLiteralExpression(node)) {
+  if (ts13.isObjectLiteralExpression(node)) {
     const parts = node.properties.map((property) => {
-      if (ts14.isShorthandPropertyAssignment(property)) return signatureOf(property);
-      if (!ts14.isPropertyAssignment(property)) return signatureOf(property);
+      if (ts13.isShorthandPropertyAssignment(property)) return signatureOf(property);
+      if (!ts13.isPropertyAssignment(property)) return signatureOf(property);
       const init = resolveRememberTemp(property.initializer, temps, /* @__PURE__ */ new Set());
-      if (ts14.isIdentifier(property.name) && ts14.isIdentifier(init) && property.name.text === init.text) {
-        return signatureOf(ts14.factory.createShorthandPropertyAssignment(property.name));
+      if (ts13.isIdentifier(property.name) && ts13.isIdentifier(init) && property.name.text === init.text) {
+        return signatureOf(ts13.factory.createShorthandPropertyAssignment(property.name));
       }
-      if (ts14.isComputedPropertyName(property.name)) {
+      if (ts13.isComputedPropertyName(property.name)) {
         const key = resolveRememberTemp(property.name.expression, temps, /* @__PURE__ */ new Set());
         return `PropertyAssignment[ComputedPropertyName[${signatureOfSubstituted(key, temps)}],${signatureOfSubstituted(init, temps)}]`;
       }
@@ -3576,7 +3432,7 @@ var signatureOfSubstituted = (node, temps) => {
     });
     return `ObjectLiteralExpression[${parts.join(",")}]`;
   }
-  if (ts14.isArrayLiteralExpression(node)) {
+  if (ts13.isArrayLiteralExpression(node)) {
     const parts = node.elements.map(
       (element) => signatureOfSubstituted(resolveRememberTemp(element, temps, /* @__PURE__ */ new Set()), temps)
     );
@@ -3594,33 +3450,33 @@ var signatureOf = (node) => {
   if (unwrapped !== node) return signatureOf(unwrapped);
   const remembered = signatureOfRememberedLiteral(unwrapped);
   if (remembered !== void 0) return remembered;
-  if (ts14.isPropertyAssignment(unwrapped) && ts14.isIdentifier(unwrapped.name) && ts14.isIdentifier(unwrapped.initializer) && unwrapped.name.text === unwrapped.initializer.text) {
-    return signatureOf(ts14.factory.createShorthandPropertyAssignment(unwrapped.name));
+  if (ts13.isPropertyAssignment(unwrapped) && ts13.isIdentifier(unwrapped.name) && ts13.isIdentifier(unwrapped.initializer) && unwrapped.name.text === unwrapped.initializer.text) {
+    return signatureOf(ts13.factory.createShorthandPropertyAssignment(unwrapped.name));
   }
-  if (ts14.isEmptyStatement(unwrapped) || isRasputinStatement(unwrapped)) return "";
-  if (ts14.isTryStatement(unwrapped) && isRasputinTryWrapper(unwrapped)) {
+  if (ts13.isEmptyStatement(unwrapped) || isRasputinStatement(unwrapped)) return "";
+  if (ts13.isTryStatement(unwrapped) && isRasputinTryWrapper(unwrapped)) {
     return flattenStatements(unwrapped.tryBlock.statements).map(signatureOf).filter(Boolean).join("");
   }
-  if (ts14.isCatchClause(unwrapped)) {
+  if (ts13.isCatchClause(unwrapped)) {
     const statements = flattenStatements(unwrapped.block.statements);
     const variable = unwrapped.variableDeclaration ? signatureOf(unwrapped.variableDeclaration) : "";
     return `Catch${variable}[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
   }
-  if (ts14.isBlock(unwrapped)) {
+  if (ts13.isBlock(unwrapped)) {
     const statements = flattenStatements(unwrapped.statements);
     return `Block[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
   }
-  if (ts14.isArrowFunction(unwrapped) && ts14.isBlock(unwrapped.body)) {
+  if (ts13.isArrowFunction(unwrapped) && ts13.isBlock(unwrapped.body)) {
     const raw = unwrapped.body.statements;
-    const tryWrap = raw.length === 1 && raw[0] && ts14.isTryStatement(raw[0]) ? raw[0] : void 0;
+    const tryWrap = raw.length === 1 && raw[0] && ts13.isTryStatement(raw[0]) ? raw[0] : void 0;
     const inner = tryWrap && isRasputinTryWrapper(tryWrap) ? tryWrap.tryBlock.statements : raw;
     const temp = inner[0] ? customerTempInit(inner[0]) : void 0;
     const returned = inner[1];
-    if (temp && returned && ts14.isReturnStatement(returned) && returned.expression && inner.length === 2) {
+    if (temp && returned && ts13.isReturnStatement(returned) && returned.expression && inner.length === 2) {
       const value = unwrapCall(returned.expression);
-      if (ts14.isIdentifier(value) && value.text === temp.name) {
+      if (ts13.isIdentifier(value) && value.text === temp.name) {
         const parts2 = [];
-        ts14.forEachChild(unwrapped, (child) => {
+        ts13.forEachChild(unwrapped, (child) => {
           if (child === unwrapped.body) {
             const part2 = signatureOf(temp.init);
             if (part2) parts2.push(part2);
@@ -3634,10 +3490,10 @@ var signatureOf = (node) => {
     }
     const statements = flattenStatements(unwrapped.body.statements);
     const only = statements[0];
-    const onlyExpression = only && ts14.isReturnStatement(only) ? only.expression : void 0;
+    const onlyExpression = only && ts13.isReturnStatement(only) ? only.expression : void 0;
     if (statements.length === 1 && onlyExpression) {
       const parts2 = [];
-      ts14.forEachChild(unwrapped, (child) => {
+      ts13.forEachChild(unwrapped, (child) => {
         if (child === unwrapped.body) {
           const part2 = signatureOf(onlyExpression);
           if (part2) parts2.push(part2);
@@ -3649,20 +3505,20 @@ var signatureOf = (node) => {
       return `ArrowFunction[${parts2.join(",")}]`;
     }
   }
-  if (ts14.isReturnStatement(unwrapped)) {
+  if (ts13.isReturnStatement(unwrapped)) {
     if (!unwrapped.expression) return "ReturnStatement[]";
     const expression = unwrapCall(unwrapped.expression);
-    if (ts14.isVoidExpression(expression) && isRasputinCall(expression.expression)) {
+    if (ts13.isVoidExpression(expression) && isRasputinCall(expression.expression)) {
       return "ReturnStatement[]";
     }
     return `Return[${signatureOf(unwrapped.expression)}]`;
   }
   const parts = [];
-  ts14.forEachChild(unwrapped, (child) => {
+  ts13.forEachChild(unwrapped, (child) => {
     const part = signatureOf(child);
     if (part) parts.push(part);
   });
-  const kind = ts14.SyntaxKind[unwrapped.kind] ?? "Node";
+  const kind = ts13.SyntaxKind[unwrapped.kind] ?? "Node";
   return `${kind}${extra(unwrapped)}[${parts.join(",")}]`;
 };
 var browserInstrumentationIsSafe = (filePath, original, transformed) => {
@@ -3685,6 +3541,15 @@ var refuse = (source, classifications) => ({
   verificationFailed: true
 });
 var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleIndex = 0, options) => {
+  if (isSvelteCompiledPath(filePath) && !options?.policy) {
+    return {
+      code: source,
+      classifications: [],
+      sites: [],
+      identities: [],
+      delta: { functions: [], callSites: [], destructures: [] }
+    };
+  }
   if (source.includes("@rasputin-ignore-file") || sourceIsRasputinInstrumented(source)) {
     return {
       code: source,
@@ -3695,7 +3560,12 @@ var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleInd
     };
   }
   const sourceFile = parseSource(source, filePath);
-  const classifications = classifyFunctions(source, filePath, options?.mapLocation);
+  const classifications = classifyFunctions(
+    source,
+    filePath,
+    options?.mapLocation,
+    options?.policy
+  );
   const observe = collectObserveSiteEdits(
     source,
     filePath,
@@ -3703,7 +3573,10 @@ var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleInd
     sourceFile
   );
   const literals = collectLiteralSiteEdits(source, filePath, { classifications }, sourceFile);
-  const json = collectJsonProducerEdits(source, filePath, sourceFile, { adoptCalls: true });
+  const json = collectJsonProducerEdits(source, filePath, sourceFile, {
+    adoptCalls: true,
+    policy: options?.policy
+  });
   const functions = collectBrowserFunctionEdits(
     source,
     sourceFile,
@@ -3714,7 +3587,8 @@ var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleInd
       observe: observe.sites.length > 0,
       struct: literals.edits.length > 0,
       includePlans: options?.includePlans === true,
-      mapLocation: options?.mapLocation
+      mapLocation: options?.mapLocation,
+      policy: options?.policy
     }
   );
   const edits = [...observe.edits, ...literals.edits, ...json.edits, ...functions.edits];
@@ -3745,11 +3619,11 @@ var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleInd
 import { basename as basename3 } from "node:path";
 
 // ../instrumentation/src/provenance-function-edits.ts
-import ts15 from "typescript";
+import ts14 from "typescript";
 var PROVENANCE_HANDLE_CALLEE = "globalThis.__rasputinN";
 var PROVENANCE_HANDLE_GUARD = "globalThis.__rasputinN??=function(){return{leave:function(v){return v},end:function(){},suspend:function(v){return v},resume:function(v){return v}}};";
-var isProvenanceTarget = (node) => (ts15.isFunctionDeclaration(node) || ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isMethodDeclaration(node)) && node.body !== void 0 && !node.asteriskToken;
-var isDirectivePrologue2 = (statement) => ts15.isExpressionStatement(statement) && ts15.isStringLiteral(statement.expression);
+var isProvenanceTarget = (node) => (ts14.isFunctionDeclaration(node) || ts14.isFunctionExpression(node) || ts14.isArrowFunction(node) || ts14.isMethodDeclaration(node)) && node.body !== void 0 && !node.asteriskToken;
+var isDirectivePrologue2 = (statement) => ts14.isExpressionStatement(statement) && ts14.isStringLiteral(statement.expression);
 var insertPositionAfterPrologue2 = (source, sourceFile) => {
   const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
   let end = shebangEnd;
@@ -3775,15 +3649,15 @@ var functionBodyPrologueEnd2 = (body, sourceFile) => {
 var walkOwnBody2 = (node, visitNode) => {
   if (!node.body) return;
   const visit = (candidate) => {
-    if (candidate !== node && ts15.isFunctionLike(candidate)) return;
+    if (candidate !== node && ts14.isFunctionLike(candidate)) return;
     visitNode(candidate);
-    ts15.forEachChild(candidate, visit);
+    ts14.forEachChild(candidate, visit);
   };
   visit(node.body);
 };
 var producerName = (node) => {
   const callee = peel(node.expression);
-  if (ts15.isPropertyAccessExpression(callee) && ts15.isIdentifier(callee.name)) {
+  if (ts14.isPropertyAccessExpression(callee) && ts14.isIdentifier(callee.name)) {
     return callee.name.text;
   }
   return void 0;
@@ -3822,10 +3696,10 @@ var callCanCarryProvenance2 = (node) => {
   if (name === "json" || name === "parse") return true;
   if (name === "call" || name === "apply") return false;
   const callee = peel(node.expression);
-  if (ts15.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS2.has(callee.text);
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts14.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS2.has(callee.text);
+  if (ts14.isPropertyAccessExpression(callee)) {
     const object = peel(callee.expression);
-    if (ts15.isIdentifier(object) && NON_PROVENANCE_ROOTS2.has(object.text)) {
+    if (ts14.isIdentifier(object) && NON_PROVENANCE_ROOTS2.has(object.text)) {
       return object.text === "JSON" && callee.name.text === "parse";
     }
   }
@@ -3833,29 +3707,29 @@ var callCanCarryProvenance2 = (node) => {
 };
 var returnedExpressionNeedsProvenance = (expression) => {
   const inner = peel(expression);
-  if (ts15.isAwaitExpression(inner)) return true;
-  if (ts15.isCallExpression(inner)) return callCanCarryProvenance2(inner);
+  if (ts14.isAwaitExpression(inner)) return true;
+  if (ts14.isCallExpression(inner)) return callCanCarryProvenance2(inner);
   return false;
 };
 var functionNeedsProvenance = (node) => {
-  if (ts15.isArrowFunction(node) && !ts15.isBlock(node.body)) {
+  if (ts14.isArrowFunction(node) && !ts14.isBlock(node.body)) {
     const body = peel(node.body);
-    if (ts15.isAwaitExpression(body)) return true;
-    if (ts15.isCallExpression(body)) return callCanCarryProvenance2(body);
+    if (ts14.isAwaitExpression(body)) return true;
+    if (ts14.isCallExpression(body)) return callCanCarryProvenance2(body);
     return false;
   }
   let needed = false;
   walkOwnBody2(node, (candidate) => {
     if (needed) return;
-    if (ts15.isAwaitExpression(candidate)) {
+    if (ts14.isAwaitExpression(candidate)) {
       needed = true;
       return;
     }
-    if (ts15.isReturnStatement(candidate) && candidate.expression) {
+    if (ts14.isReturnStatement(candidate) && candidate.expression) {
       if (returnedExpressionNeedsProvenance(candidate.expression)) needed = true;
       return;
     }
-    if (ts15.isCallExpression(candidate)) {
+    if (ts14.isCallExpression(candidate)) {
       const name = producerName(candidate);
       if (name === "json" || name === "parse") needed = true;
     }
@@ -3863,9 +3737,9 @@ var functionNeedsProvenance = (node) => {
   return needed;
 };
 var collectReturnWraps2 = (node, sourceFile, handleName, edits) => {
-  if (!ts15.isBlock(node.body)) return;
+  if (!ts14.isBlock(node.body)) return;
   walkOwnBody2(node, (candidate) => {
-    if (!ts15.isReturnStatement(candidate) || !candidate.expression) return;
+    if (!ts14.isReturnStatement(candidate) || !candidate.expression) return;
     wrap(
       edits,
       candidate.expression.getStart(sourceFile),
@@ -3878,7 +3752,7 @@ var collectReturnWraps2 = (node, sourceFile, handleName, edits) => {
 };
 var collectAwaitSuspends = (node, sourceFile, handleName, edits) => {
   walkOwnBody2(node, (candidate) => {
-    if (!ts15.isAwaitExpression(candidate)) return;
+    if (!ts14.isAwaitExpression(candidate)) return;
     wrap(
       edits,
       candidate.expression.getStart(sourceFile),
@@ -3890,12 +3764,12 @@ var collectAwaitSuspends = (node, sourceFile, handleName, edits) => {
   });
 };
 var functionRef2 = (node) => {
-  if (node.name && ts15.isIdentifier(node.name)) {
-    if (ts15.isMethodDeclaration(node)) return void 0;
+  if (node.name && ts14.isIdentifier(node.name)) {
+    if (ts14.isMethodDeclaration(node)) return void 0;
     return node.name.text;
   }
   const parent = node.parent;
-  if (ts15.isVariableDeclaration(parent) && ts15.isIdentifier(parent.name) && parent.initializer === node) {
+  if (ts14.isVariableDeclaration(parent) && ts14.isIdentifier(parent.name) && parent.initializer === node) {
     return parent.name.text;
   }
   return void 0;
@@ -3912,7 +3786,7 @@ var collectProvenanceFunctionEdits = (source, sourceFile) => {
         const ref = functionRef2(node);
         const enter = ref ? `${PROVENANCE_HANDLE_CALLEE}(${ref})` : `${PROVENANCE_HANDLE_CALLEE}()`;
         const epilogue = `}catch(${errorName}){throw ${errorName};}finally{${handleName}.end();}`;
-        if (ts15.isBlock(node.body)) {
+        if (ts14.isBlock(node.body)) {
           const openAt = functionBodyPrologueEnd2(node.body, sourceFile);
           const closeAt = node.body.end - 1;
           wrap(edits, openAt, closeAt, `;const ${handleName}=${enter};try{`, epilogue, 0);
@@ -3936,7 +3810,7 @@ var collectProvenanceFunctionEdits = (source, sourceFile) => {
         functionWraps += 1;
       }
     }
-    ts15.forEachChild(node, visit);
+    ts14.forEachChild(node, visit);
   };
   visit(sourceFile);
   if (functionWraps > 0) {
@@ -4003,7 +3877,7 @@ var instrumentProvenanceSource = (source, filePath) => {
 };
 
 // ../instrumentation/src/provenance-coverage.ts
-var isRasputinSdkPath = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/");
+var isRasputinSdkPath = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/") || path.includes("/sveltekit/src/") || path.includes("/sveltekit/dist/");
 var isBundledDependencyPath = (path) => /(^|\/)node_modules\//.test(path) || path.includes("/.vite/deps/") || path.includes("node_modules/.vite/deps/");
 var coverageForModule = (filePath, options) => {
   const path = filePath.replaceAll("\\", "/");
@@ -4084,6 +3958,13 @@ var contentDebugId = (source) => {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
 };
 var contentHash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
+var omitSourceMapSourcesContent = (map) => {
+  if (!map || typeof map !== "object" || Array.isArray(map)) return map;
+  if (!("sourcesContent" in map)) return map;
+  const next = { ...map };
+  Reflect.deleteProperty(next, "sourcesContent");
+  return next;
+};
 var summarizeClassification = (functions, expressionSites) => {
   const counts = {
     full: 0,
@@ -4149,24 +4030,26 @@ var uploadBrowserArtifacts = async (input) => {
     ""
   );
   try {
+    const { body, gzip } = encodeJsonRequestBody({
+      buildId: input.artifacts.buildId,
+      release: input.release,
+      contentHash: contentHash(input.artifacts),
+      artifact: input.artifacts,
+      ...input.replace === true ? { replace: true } : {}
+    });
     const response = await fetch(`${apiUrl}/browserArtifacts`, {
       method: "POST",
       headers: {
         authorization: `Bearer ${key}`,
-        "content-type": "application/json"
+        "content-type": "application/json",
+        ...gzip ? { "content-encoding": "gzip" } : {}
       },
-      body: JSON.stringify({
-        buildId: input.artifacts.buildId,
-        release: input.release,
-        contentHash: contentHash(input.artifacts),
-        artifact: input.artifacts,
-        ...input.replace === true ? { replace: true } : {}
-      })
+      body
     });
     if (response.status === 409) return "conflict";
     if (response.status === 200 || response.status === 201) {
-      const body = await response.json().catch(() => ({}));
-      if (body && typeof body === "object" && "duplicate" in body && body.duplicate === true) {
+      const body2 = await response.json().catch(() => ({}));
+      if (body2 && typeof body2 === "object" && "duplicate" in body2 && body2.duplicate === true) {
         return "duplicate";
       }
       return "uploaded";
@@ -4183,7 +4066,7 @@ var uploadBrowserArtifacts = async (input) => {
 
 // src/vite/plugin.ts
 var isServerModule = (path) => path.includes(".server.") || path.endsWith("+server.ts") || path.endsWith("+server.js") || path.includes("/hooks.server.");
-var isRasputinSdkModule = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/");
+var isRasputinSdkModule = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/") || path.includes("/sveltekit/src/") || path.includes("/sveltekit/dist/");
 var isRasputinBrowserRuntimeSource = (code) => code.includes("rasputin.browser.client.v1");
 var isJsModulePath = (path) => /\.[cm]?[jt]sx?$/.test(path) && !isSvelteCompiledPath(path);
 var MAX_PROVENANCE_SOURCE_CHARS = 15e5;
@@ -4365,7 +4248,10 @@ var rasputin = (options) => {
       destructures: [...destructures.values()],
       expressionSites: sites,
       classification: summarizeClassification(manifestFunctions, sites),
-      debugImages,
+      debugImages: debugImages.map((image) => ({
+        ...image,
+        map: omitSourceMapSourcesContent(image.map)
+      })),
       verificationFailed: [...verificationFailed],
       provenance: { ...provenanceStats }
     };