@scene-glass/devtools 0.0.0-stage → 0.1.32

package/dist/vite.js

@@ -0,0 +1,1608 @@
+// packages/devtools/src/vite/runtime-authority.ts
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/contracts/src/limits.ts
+var MAX_SAFE_REVISION = Number.MAX_SAFE_INTEGER;
+var SceneGlassContractError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SceneGlassContractError";
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LIMIT_DEFAULTS = {
+  httpBodyBytes: 1 * 1024 * 1024,
+  canonicalIdentityBytes: 2048,
+  routeBytes: 2048,
+  memoBytes: 16 * 1024,
+  surroundingTextCodePoints: 500,
+  surroundingTextBytes: 4 * 1024,
+  locatorFieldBytes: 512,
+  locatorSerializedBytes: 16 * 1024,
+  annotationsPerPage: 1e3,
+  pageFileBytes: 8 * 1024 * 1024,
+  replayLedgerBytes: 2 * 1024 * 1024,
+  replayResultBytes: 64 * 1024,
+  pagesPerProject: 2e3,
+  exportScanBytes: 64 * 1024 * 1024,
+  exportRenderBytes: 16 * 1024 * 1024,
+  concurrentRequestsPerProject: 16,
+  concurrentRequestsGlobal: 64,
+  normalSessionsPerProject: 32,
+  normalSessionsGlobal: 128,
+  sessionMaxAgeMs: 30 * 60 * 1e3,
+  sessionIdleMs: 5 * 60 * 1e3,
+  diagnosticActiveRunsPerProject: 4,
+  diagnosticActiveRunsGlobal: 16,
+  diagnosticRunsPerProjectPerMinute: 5,
+  requestTimeoutMs: 30 * 1e3,
+  exportTimeoutMs: 60 * 1e3,
+  workRequestAnnotations: 1e3,
+  workRequestEvents: 32,
+  historyTaskCount: 32,
+  historyBudgetBytes: 256 * 1024 * 1024,
+  historyScanFiles: 2e4,
+  historyScanBytes: 512 * 1024 * 1024,
+  historyFileBytes: 16 * 1024 * 1024,
+  historyDiffRenderBytes: 8 * 1024 * 1024,
+  historyHashConcurrency: 16
+};
+var BUILT_IN_LIMITS = Object.freeze(LIMIT_DEFAULTS);
+var GLOBAL_ONLY_LIMIT_NAMES = [
+  "httpBodyBytes",
+  "concurrentRequestsGlobal",
+  "normalSessionsGlobal",
+  "diagnosticActiveRunsGlobal",
+  "historyHashConcurrency"
+];
+var GLOBAL_ONLY_LIMIT_NAME_SET = new Set(
+  GLOBAL_ONLY_LIMIT_NAMES
+);
+var GLOBAL_LIMIT_OVERRIDE_KEYS = Object.freeze(
+  Object.keys(BUILT_IN_LIMITS)
+);
+var PROJECT_LIMIT_OVERRIDE_KEYS = Object.freeze(
+  GLOBAL_LIMIT_OVERRIDE_KEYS.filter(
+    (key) => !GLOBAL_ONLY_LIMIT_NAME_SET.has(key)
+  )
+);
+var REPLAY_RECORD_COUNT_OVERRIDE_ALIASES = Object.freeze([
+  "replayRecordCount",
+  "replayRecordsCount",
+  "replayWindowSize",
+  "replayWindowCount",
+  "replayCount",
+  "replayCountLimit",
+  "recordCount",
+  "replayRecords"
+]);
+function assertSafeRevision(value, name = "revision") {
+  return assertIntegerInRange(value, 0, MAX_SAFE_REVISION, name);
+}
+function assertIntegerInRange(value, minimum, maximum, name = "value") {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new SceneGlassContractError(
+      "SCG_SCALAR_INVALID",
+      `${name} must be a safe integer from ${minimum} through ${maximum}`
+    );
+  }
+  return value;
+}
+function assertLowercaseUuidV4(value, name = "id") {
+  if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value)) {
+    throw new SceneGlassContractError("SCG_ID_INVALID", `${name} must be a lowercase UUID v4`);
+  }
+  return value;
+}
+
+// packages/contracts/src/annotations.ts
+var SHA256_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var MAX_CONTEXT_SERIALIZED_BYTES = 16 * 1024;
+function parseSha256Digest(value) {
+  if (typeof value !== "string" || !SHA256_DIGEST_PATTERN.test(value)) {
+    throw new SceneGlassContractError("SCG_ID_INVALID", "digest must be a lowercase sha256 digest");
+  }
+  return value;
+}
+
+// packages/contracts/src/coupon.ts
+var COUPON_CAPABILITIES = Object.freeze(["measure-distance", "measure-size"]);
+
+// packages/contracts/src/premium.ts
+var PREMIUM_MEASUREMENT_NAMESPACE_V1 = "scene-glass-premium-measurement-v1";
+var PREMIUM_MEASUREMENT_ABI_V1 = 1;
+var MAX_PREMIUM_MODULE_BYTES = 256 * 1024;
+var MAX_PREMIUM_STYLESHEET_BYTES = 64 * 1024;
+var PREMIUM_MEASUREMENT_MODULE_PATH_V1 = "premium/measurement-v1.js";
+var PREMIUM_MEASUREMENT_STYLESHEET_PATH_V1 = "premium/measurement-v1.css";
+var PREMIUM_MODULE_MEDIA_TYPE_V1 = "application/javascript; charset=utf-8";
+var PREMIUM_STYLESHEET_MEDIA_TYPE_V1 = "text/css; charset=utf-8";
+var SCENE_GLASS_NATIVE_TUPLES_V1 = Object.freeze(["darwin-arm64", "darwin-x64", "linux-x64-gnu"]);
+function parseSceneGlassReleaseManifestV1(value) {
+  const hasPredecessor = isOrdinaryRecord(value) && Object.hasOwn(value, "lifecyclePredecessor");
+  const hasAncestors = isOrdinaryRecord(value) && Object.hasOwn(value, "lifecycleAncestors");
+  const manifest = exactRecord(
+    value,
+    [
+      "schemaVersion",
+      "package",
+      "artifacts",
+      ...hasPredecessor ? ["lifecyclePredecessor"] : [],
+      ...hasAncestors ? ["lifecycleAncestors"] : []
+    ],
+    "release manifest"
+  );
+  if (manifest.schemaVersion !== 1) {
+    throw invalid("release manifest schemaVersion must be 1");
+  }
+  const releasePackage = parseReleasePackage(manifest.package);
+  const artifacts = parseReleaseArtifacts(manifest.artifacts);
+  const lifecyclePredecessor = hasPredecessor ? parseLifecyclePredecessor(manifest.lifecyclePredecessor, releasePackage.version) : void 0;
+  const lifecycleAncestors = hasAncestors ? parseLifecycleAncestors(manifest.lifecycleAncestors, lifecyclePredecessor) : void 0;
+  return Object.freeze({
+    schemaVersion: 1,
+    package: releasePackage,
+    artifacts,
+    ...lifecyclePredecessor === void 0 ? {} : { lifecyclePredecessor },
+    ...lifecycleAncestors === void 0 ? {} : { lifecycleAncestors }
+  });
+}
+function parseLifecycleAncestors(value, predecessor) {
+  if (predecessor === void 0 || !Array.isArray(value) || value.length === 0) {
+    throw invalid("lifecycle ancestors require a predecessor and at least one entry");
+  }
+  let successorVersion = predecessor.package.version;
+  const ancestors = value.map((entry, index) => {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) {
+      throw invalid("lifecycle ancestors must not be sparse");
+    }
+    const ancestor = parseLifecyclePredecessor(entry, successorVersion);
+    successorVersion = ancestor.package.version;
+    return ancestor;
+  });
+  return Object.freeze(ancestors);
+}
+function parseReleasePackage(value) {
+  const packageRecord = exactRecord(value, ["name", "version"], "release package");
+  if (packageRecord.name !== "@scene-glass/devtools" || typeof packageRecord.version !== "string" || !isCanonicalPackageVersion(packageRecord.version)) {
+    throw invalid("release package identity is invalid");
+  }
+  return Object.freeze({
+    name: "@scene-glass/devtools",
+    version: packageRecord.version
+  });
+}
+function parseReleaseArtifacts(value) {
+  const artifacts = exactRecord(
+    value,
+    ["cli", "freeLoader", "native", "premiumMeasurement"],
+    "release artifacts"
+  );
+  return Object.freeze({
+    cli: parseArtifact(artifacts.cli, "CLI artifact"),
+    freeLoader: parseArtifact(artifacts.freeLoader, "free loader artifact"),
+    native: parseNativeArtifacts(artifacts.native),
+    premiumMeasurement: parsePremiumArtifact(artifacts.premiumMeasurement)
+  });
+}
+function parseLifecyclePredecessor(value, successorVersion) {
+  const predecessor = exactRecord(
+    value,
+    ["releaseManifestSha256", "package", "artifacts"],
+    "lifecycle predecessor"
+  );
+  const releasePackage = parseReleasePackage(predecessor.package);
+  if (comparePackageVersions(releasePackage.version, successorVersion) >= 0) {
+    throw invalid("lifecycle predecessor version must precede the release package version");
+  }
+  return Object.freeze({
+    releaseManifestSha256: parseSha256(
+      predecessor.releaseManifestSha256,
+      "lifecycle predecessor manifest"
+    ),
+    package: releasePackage,
+    artifacts: parseReleaseArtifacts(predecessor.artifacts)
+  });
+}
+function parseArtifact(value, label) {
+  const record = exactRecord(value, ["path", "sha256"], label);
+  return Object.freeze({
+    path: parsePackageArtifactPath(record.path, label),
+    sha256: parseSha256(record.sha256, label)
+  });
+}
+function parseNativeArtifacts(value) {
+  if (!Array.isArray(value) || value.length !== SCENE_GLASS_NATIVE_TUPLES_V1.length) {
+    throw invalid("native artifacts must contain every supported tuple");
+  }
+  const parsed = SCENE_GLASS_NATIVE_TUPLES_V1.map((tuple, index) => {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) {
+      throw invalid("native artifacts must not be sparse");
+    }
+    const record = exactRecord(value[index], ["tuple", "path", "sha256"], "native artifact");
+    if (record.tuple !== tuple) {
+      throw invalid("native artifacts must use the canonical tuple order");
+    }
+    return Object.freeze({
+      tuple,
+      path: parsePackageArtifactPath(record.path, "native artifact"),
+      sha256: parseSha256(record.sha256, "native artifact")
+    });
+  });
+  return Object.freeze(parsed);
+}
+function parsePremiumArtifact(value) {
+  const record = exactRecord(
+    value,
+    ["moduleId", "namespace", "abiVersion", "module", "stylesheet"],
+    "premium measurement artifact"
+  );
+  if (record.moduleId !== PREMIUM_MEASUREMENT_NAMESPACE_V1 || record.namespace !== PREMIUM_MEASUREMENT_NAMESPACE_V1 || record.abiVersion !== PREMIUM_MEASUREMENT_ABI_V1) {
+    throw invalid("premium measurement artifact identity or ABI is invalid");
+  }
+  return Object.freeze({
+    moduleId: PREMIUM_MEASUREMENT_NAMESPACE_V1,
+    namespace: PREMIUM_MEASUREMENT_NAMESPACE_V1,
+    abiVersion: PREMIUM_MEASUREMENT_ABI_V1,
+    module: parsePremiumModuleArtifact(record.module),
+    stylesheet: parsePremiumStylesheetArtifact(record.stylesheet)
+  });
+}
+function parsePremiumModuleArtifact(value) {
+  const record = parsePremiumFileArtifact(value, "premium measurement module");
+  if (record.path !== PREMIUM_MEASUREMENT_MODULE_PATH_V1 || record.maxBytes !== MAX_PREMIUM_MODULE_BYTES || record.mediaType !== PREMIUM_MODULE_MEDIA_TYPE_V1) {
+    throw invalid("premium measurement module authority is invalid");
+  }
+  return Object.freeze({
+    path: PREMIUM_MEASUREMENT_MODULE_PATH_V1,
+    maxBytes: MAX_PREMIUM_MODULE_BYTES,
+    mediaType: PREMIUM_MODULE_MEDIA_TYPE_V1,
+    sha256: record.sha256
+  });
+}
+function parsePremiumStylesheetArtifact(value) {
+  const record = parsePremiumFileArtifact(value, "premium measurement stylesheet");
+  if (record.path !== PREMIUM_MEASUREMENT_STYLESHEET_PATH_V1 || record.maxBytes !== MAX_PREMIUM_STYLESHEET_BYTES || record.mediaType !== PREMIUM_STYLESHEET_MEDIA_TYPE_V1) {
+    throw invalid("premium measurement stylesheet authority is invalid");
+  }
+  return Object.freeze({
+    path: PREMIUM_MEASUREMENT_STYLESHEET_PATH_V1,
+    maxBytes: MAX_PREMIUM_STYLESHEET_BYTES,
+    mediaType: PREMIUM_STYLESHEET_MEDIA_TYPE_V1,
+    sha256: record.sha256
+  });
+}
+function parsePremiumFileArtifact(value, label) {
+  const record = exactRecord(value, ["path", "maxBytes", "mediaType", "sha256"], label);
+  const path = parsePackageArtifactPath(record.path, label);
+  if (typeof record.maxBytes !== "number" || !Number.isSafeInteger(record.maxBytes) || record.maxBytes < 1 || typeof record.mediaType !== "string") {
+    throw invalid(`${label} media type or size bound is invalid`);
+  }
+  return Object.freeze({
+    path,
+    maxBytes: record.maxBytes,
+    mediaType: record.mediaType,
+    sha256: parseSha256(record.sha256, label)
+  });
+}
+function parsePackageArtifactPath(value, label) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 256 || value.startsWith("/") || value.endsWith("/") || value.includes("\\") || value.includes("\0") || value.includes("?") || value.includes("#")) {
+    throw invalid(`${label} path is not package-relative`);
+  }
+  const segments = value.split("/");
+  if (segments.some(
+    (segment) => segment.length === 0 || segment === "." || segment === ".." || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(segment)
+  )) {
+    throw invalid(`${label} path is not package-relative`);
+  }
+  return value;
+}
+function parseSha256(value, label) {
+  if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(value)) {
+    throw invalid(`${label} SHA-256 is invalid`);
+  }
+  return value;
+}
+function isCanonicalPackageVersion(value) {
+  return /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)$/u.test(value);
+}
+function comparePackageVersions(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function exactRecord(value, keys, label) {
+  if (!isOrdinaryRecord(value)) {
+    throw invalid(`${label} must be an object`);
+  }
+  const actualKeys = Reflect.ownKeys(value);
+  if (actualKeys.length !== keys.length || actualKeys.some((key) => typeof key !== "string" || !keys.includes(key))) {
+    throw invalid(`${label} contains missing or unknown fields`);
+  }
+  return value;
+}
+function isOrdinaryRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function invalid(message) {
+  return new TypeError(message);
+}
+
+// packages/contracts/src/work-contract-internal.ts
+var UTC_TIMESTAMP_PATTERN = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,3}))?Z$/;
+var MAX_PROJECT_RELATIVE_PATH_BYTES = BUILT_IN_LIMITS.routeBytes;
+function createWorkFieldParsers(code) {
+  const fail = (message) => new SceneGlassContractError(code, message);
+  const mapped = (message, parse) => {
+    try {
+      return parse();
+    } catch (error) {
+      if (error instanceof SceneGlassContractError) {
+        throw fail(message);
+      }
+      throw error;
+    }
+  };
+  return Object.freeze({
+    fail,
+    mapped,
+    record: (value, name) => {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw fail(`${name} must be an object`);
+      }
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw fail(`${name} must be a plain object`);
+      }
+      return value;
+    },
+    field: (record, key) => Reflect.get(record, key),
+    exactKeys: (record, keys, name) => {
+      for (const key of Reflect.ownKeys(record)) {
+        if (typeof key !== "string" || !keys.has(key)) {
+          throw fail(`${name} contains an unknown field`);
+        }
+      }
+      for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(record, key)) {
+          throw fail(`${name} is missing ${key}`);
+        }
+      }
+    },
+    denseArray: (value, name) => {
+      if (!Array.isArray(value)) {
+        throw fail(`${name} must be an array`);
+      }
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(value, index)) {
+          throw fail(`${name} must not be sparse`);
+        }
+      }
+      return Object.freeze(Array.from(value, (entry) => entry));
+    },
+    unique: (values, name) => {
+      if (new Set(values).size !== values.length) {
+        throw fail(`${name} must not contain duplicates`);
+      }
+    },
+    member: (value, members, name) => {
+      for (const member of members) {
+        if (value === member) {
+          return member;
+        }
+      }
+      throw fail(`${name} is invalid`);
+    },
+    uuid: (value, name) => mapped(`${name} must be a lowercase UUID v4`, () => assertLowercaseUuidV4(value, name)),
+    digest: (value, name) => mapped(`${name} must be a lowercase sha256 digest`, () => parseSha256Digest(value)),
+    integer: (value, name) => mapped(`${name} must be a non-negative safe integer`, () => assertSafeRevision(value, name)),
+    flag: (value, name) => {
+      if (typeof value !== "boolean") {
+        throw fail(`${name} must be a boolean`);
+      }
+      return value;
+    },
+    text: (value, name) => {
+      if (typeof value !== "string") {
+        throw fail(`${name} must be a string`);
+      }
+      return value;
+    },
+    timestamp: (value, name) => {
+      if (typeof value !== "string") {
+        throw fail(`${name} must be an exact UTC ISO timestamp`);
+      }
+      const match = UTC_TIMESTAMP_PATTERN.exec(value);
+      const base = match?.[1];
+      const fraction = match?.[2] ?? "";
+      if (base === void 0) {
+        throw fail(`${name} must be an exact UTC ISO timestamp`);
+      }
+      const parsed = new Date(value);
+      const canonical = `${base}.${fraction.padEnd(3, "0")}Z`;
+      if (Number.isNaN(parsed.valueOf()) || parsed.toISOString() !== canonical) {
+        throw fail(`${name} must be an exact UTC ISO timestamp`);
+      }
+      return value;
+    },
+    schemaVersion: (value, name) => {
+      if (value !== 1) {
+        throw fail(`${name} schemaVersion must be 1`);
+      }
+    }
+  });
+}
+
+// packages/contracts/src/work-execution-settings.ts
+var INHERITED_WORK_PROVIDER_EXECUTION_SETTINGS = Object.freeze({ model: null, reasoningEffort: null });
+var fields = createWorkFieldParsers("SCG_WORK_EXECUTION_SETTINGS_INVALID");
+
+// packages/contracts/src/work-provider-runtime.ts
+var WORK_PROVIDER_RUNTIME_CODES = [
+  "SCG_OMO_RUNTIME_AUTHORITY_ABSENT",
+  "SCG_OMO_RUNTIME_UNSUPPORTED",
+  "SCG_OMO_RUNTIME_MISSING",
+  "SCG_OMO_RUNTIME_INTEGRITY"
+];
+var WORK_NATIVE_PROVIDER_RUNTIME_CODES = [
+  "SCG_RUNTIME_AUTHORITY_ABSENT",
+  "SCG_RUNTIME_UNSUPPORTED",
+  "SCG_RUNTIME_MISSING",
+  "SCG_RUNTIME_INTEGRITY",
+  "SCG_RUNTIME_VERSION_MISMATCH",
+  "SCG_RUNTIME_CONVERSATION_UNQUALIFIED",
+  "SCG_RUNTIME_LEGACY_SESSION_RESTART_REQUIRED"
+];
+var ALL_RUNTIME_CODES = [
+  ...WORK_PROVIDER_RUNTIME_CODES,
+  ...WORK_NATIVE_PROVIDER_RUNTIME_CODES
+];
+var WORK_PROVIDER_RUNTIME_INSTALL_ACTION = "scene-glass omo install";
+var WORK_NATIVE_RUNTIME_INSTALL_ACTIONS = Object.freeze({
+  "claude-code": "scene-glass runtime install --provider claude",
+  "codex-cli": "scene-glass runtime install --provider codex"
+});
+var WORK_PROVIDER_RUNTIME_READINESS = Object.freeze({
+  SCG_OMO_RUNTIME_AUTHORITY_ABSENT: "unavailable",
+  SCG_OMO_RUNTIME_UNSUPPORTED: "incompatible",
+  SCG_OMO_RUNTIME_MISSING: "missing",
+  SCG_OMO_RUNTIME_INTEGRITY: "unavailable",
+  SCG_RUNTIME_AUTHORITY_ABSENT: "unavailable",
+  SCG_RUNTIME_UNSUPPORTED: "incompatible",
+  SCG_RUNTIME_MISSING: "missing",
+  SCG_RUNTIME_INTEGRITY: "unavailable",
+  SCG_RUNTIME_VERSION_MISMATCH: "incompatible",
+  SCG_RUNTIME_CONVERSATION_UNQUALIFIED: "unavailable",
+  SCG_RUNTIME_LEGACY_SESSION_RESTART_REQUIRED: "unavailable"
+});
+var runtimeFields = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+var OMO_CODES = WORK_PROVIDER_RUNTIME_CODES;
+var NATIVE_CODES = WORK_NATIVE_PROVIDER_RUNTIME_CODES;
+var WORK_PROVIDER_RUNTIME_DIAGNOSTIC_SCHEMA = Object.freeze({
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["code", "action"],
+      properties: {
+        code: { enum: OMO_CODES },
+        action: { anyOf: [{ const: WORK_PROVIDER_RUNTIME_INSTALL_ACTION }, { type: "null" }] }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["code", "action", "provider", "version"],
+      properties: {
+        code: { enum: NATIVE_CODES },
+        action: {
+          anyOf: [
+            { enum: [...Object.values(WORK_NATIVE_RUNTIME_INSTALL_ACTIONS), "start-new-session"] },
+            { type: "null" }
+          ]
+        },
+        provider: { enum: ["claude-code", "codex-cli"] },
+        version: { anyOf: [{ type: "string" }, { type: "null" }] }
+      }
+    }
+  ]
+});
+
+// packages/contracts/src/work-provider-runtime-identity.ts
+var fields2 = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+var VERSION = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+var KEYS = ["provider", "releaseVersion", "tuple", "version", "runtimeId", "binarySha256"];
+var versionSchema = { type: "string", pattern: VERSION.source };
+var digestSchema = { type: "string", pattern: "^(?!0{64}$)[a-f0-9]{64}$" };
+var WORK_PROVIDER_RUNTIME_IDENTITY_SCHEMA = Object.freeze({
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: [...KEYS, "nodeVersion", "senpiVersion"],
+      properties: {
+        provider: { const: "omo-native" },
+        releaseVersion: versionSchema,
+        tuple: { enum: ["darwin-arm64", "darwin-x64", "linux-x64-gnu"] },
+        version: versionSchema,
+        runtimeId: digestSchema,
+        binarySha256: digestSchema,
+        nodeVersion: versionSchema,
+        senpiVersion: versionSchema
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: KEYS,
+      properties: {
+        provider: { enum: ["claude-code", "codex-cli"] },
+        releaseVersion: versionSchema,
+        tuple: { enum: ["darwin-arm64", "darwin-x64", "linux-x64-gnu"] },
+        version: versionSchema,
+        runtimeId: digestSchema,
+        binarySha256: digestSchema
+      }
+    }
+  ]
+});
+
+// packages/contracts/src/work-provider-readiness.ts
+var providerFields = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+
+// packages/contracts/src/work-provider-session-warnings.ts
+var providerFields2 = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+
+// packages/contracts/src/work-provider.ts
+var providerFields3 = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+
+// packages/contracts/src/work-provider-capabilities.ts
+var fields3 = createWorkFieldParsers("SCG_WORK_CAPABILITIES_UNAVAILABLE");
+
+// packages/contracts/src/work-history.ts
+var fields4 = createWorkFieldParsers("SCG_WORK_HISTORY_INVALID");
+
+// packages/contracts/src/work-diff.ts
+var fields5 = createWorkFieldParsers("SCG_WORK_DIFF_INVALID");
+
+// packages/contracts/src/work-request-values.ts
+var WORK_TERMINAL_REQUEST_STATES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "indeterminate"
+];
+var WORK_PROVIDER_FAILURE_CAUSES = [
+  "SCG_OMO_CONVERSATION_INCOMPATIBLE",
+  "SCG_OMO_RUNTIME_AUTHORITY_ABSENT",
+  "SCG_OMO_RUNTIME_UNSUPPORTED",
+  "SCG_OMO_RUNTIME_MISSING",
+  "SCG_OMO_RUNTIME_INTEGRITY",
+  "SCG_RUNTIME_AUTHORITY_ABSENT",
+  "SCG_RUNTIME_UNSUPPORTED",
+  "SCG_RUNTIME_MISSING",
+  "SCG_RUNTIME_INTEGRITY",
+  "SCG_RUNTIME_VERSION_MISMATCH",
+  "SCG_RUNTIME_CONVERSATION_UNQUALIFIED",
+  "SCG_RUNTIME_LEGACY_SESSION_RESTART_REQUIRED"
+];
+var WORK_ERROR_CODES = [
+  "SCG_WORK_REQUEST_INVALID",
+  "SCG_WORK_PROVIDER_INVALID",
+  "SCG_WORK_EXECUTION_SETTINGS_INVALID",
+  "SCG_WORK_CAPABILITIES_UNAVAILABLE",
+  "SCG_WORK_HISTORY_INVALID",
+  "SCG_WORK_DIFF_INVALID",
+  "SCG_WORK_LIMIT_EXCEEDED",
+  "SCG_WORK_PROVIDER_NONE",
+  "SCG_WORK_PROVIDER_UNREADY",
+  "SCG_WORK_WARNING_REQUIRED",
+  "SCG_WORK_GENERATION_CONFLICT",
+  "SCG_WORK_ACTIVE",
+  "SCG_WORK_STALE_PREVIEW",
+  "SCG_WORK_NO_ELIGIBLE",
+  "SCG_WORK_NOT_FOUND",
+  "SCG_WORK_CANCELLED",
+  "SCG_WORK_INDETERMINATE",
+  ...WORK_PROVIDER_FAILURE_CAUSES
+];
+
+// packages/contracts/src/work-requests.ts
+var TERMINAL_STATES = new Set(WORK_TERMINAL_REQUEST_STATES);
+var fields6 = createWorkFieldParsers("SCG_WORK_REQUEST_INVALID");
+
+// packages/contracts/src/work-provider-inputs.ts
+var providerFields4 = createWorkFieldParsers("SCG_WORK_PROVIDER_INVALID");
+
+// packages/devtools/src/vite/runtime-authority.ts
+var DESCRIPTOR_RELATIVE_PATH = ".scg/runtime/host-descriptor.v1.json";
+var LOADER_URL = "http://127.0.0.1:4175/scene-glass-loader.js";
+var DESCRIPTOR_MAX_BYTES = 1024 * 1024;
+var CREDENTIAL_MAX_BYTES = 8 * 1024;
+var RELEASE_MANIFEST_MAX_BYTES = 64 * 1024;
+var DECIMAL_IDENTITY = /^(?:0|[1-9][0-9]{0,19})$/;
+var PROJECT_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+var INSTALL_ID = /^[A-Za-z0-9_-]{1,128}$/;
+var TOKEN = /^[A-Za-z0-9_-]{43}$/;
+var DESCRIPTOR_KEYS = Object.freeze([
+  "schemaVersion",
+  "viteVersion",
+  "framework",
+  "frameworkVersion",
+  "frameworkPluginVersion",
+  "projectId",
+  "rootTemplate",
+  "loaderUrl",
+  "host",
+  "port",
+  "credentialProjectId",
+  "credentialKey",
+  "navigation",
+  "readinessPath",
+  "approvedRootIdentity",
+  "credentialAuthorities",
+  "installId"
+]);
+function loadViteRuntimeAuthority(root) {
+  return loadViteRuntimeAuthorityWithLoader(root, LOADER_URL);
+}
+async function loadViteRuntimeAuthorityWithLoader(root, loaderUrl) {
+  const canonicalRoot = await realpath(root);
+  const rootStats = await stat(canonicalRoot, { bigint: true });
+  if (!rootStats.isDirectory() || rootStats.uid !== currentUid()) {
+    throw new Error("runtime root authority is invalid");
+  }
+  const descriptorBytes = await secureReadRegularFile(
+    join(canonicalRoot, DESCRIPTOR_RELATIVE_PATH),
+    DESCRIPTOR_MAX_BYTES
+  );
+  let descriptor;
+  try {
+    descriptor = parseDescriptor(descriptorBytes, identity(rootStats), loaderUrl);
+  } finally {
+    descriptorBytes.fill(0);
+  }
+  const canonicalCredentialPath = await realpath(descriptor.credentialAuthority.path);
+  const rootRelativeCredential = relative(canonicalRoot, canonicalCredentialPath);
+  if (canonicalCredentialPath !== descriptor.credentialAuthority.path || rootRelativeCredential === "" || rootRelativeCredential === ".." || rootRelativeCredential.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rootRelativeCredential) || dirname(canonicalCredentialPath) !== canonicalRoot) {
+    throw new Error("credential path authority is invalid");
+  }
+  const credentialBytes = await secureReadRegularFile(
+    canonicalCredentialPath,
+    CREDENTIAL_MAX_BYTES,
+    descriptor.credentialAuthority
+  );
+  try {
+    return Object.freeze({
+      loaderUrl: descriptor.loaderUrl,
+      origin: `http://127.0.0.1:${descriptor.port}`,
+      projectId: descriptor.projectId,
+      token: parseCredentialToken(credentialBytes, descriptor)
+    });
+  } finally {
+    credentialBytes.fill(0);
+  }
+}
+async function loadVitePremiumArtifactAuthority(moduleUrl) {
+  let manifestBytes;
+  let moduleBytes;
+  let stylesheetBytes;
+  try {
+    const packageRoot = await realpath(resolve(dirname(fileURLToPath(moduleUrl)), ".."));
+    manifestBytes = await secureReadPackageFile(
+      join(packageRoot, "release-manifest.json"),
+      RELEASE_MANIFEST_MAX_BYTES
+    );
+    const serialized = new TextDecoder("utf-8", { fatal: true }).decode(manifestBytes);
+    const manifestValue = JSON.parse(serialized);
+    const manifest = parseSceneGlassReleaseManifestV1(manifestValue);
+    if (`${JSON.stringify(manifest, null, 2)}
+` !== serialized) {
+      throw new Error("release manifest serialization is invalid");
+    }
+    const artifact = manifest.artifacts.premiumMeasurement;
+    const modulePath = packageArtifactPath(packageRoot, artifact.module.path);
+    const stylesheetPath = packageArtifactPath(packageRoot, artifact.stylesheet.path);
+    moduleBytes = await secureReadPackageFile(modulePath, artifact.module.maxBytes);
+    stylesheetBytes = await secureReadPackageFile(stylesheetPath, artifact.stylesheet.maxBytes);
+    if (`sha256:${createHash("sha256").update(moduleBytes).digest("hex")}` !== artifact.module.sha256 || `sha256:${createHash("sha256").update(stylesheetBytes).digest("hex")}` !== artifact.stylesheet.sha256) {
+      throw new Error("premium artifact pair digest is invalid");
+    }
+    validatePremiumModuleText(moduleBytes);
+    validatePremiumStylesheetText(stylesheetBytes);
+    return Object.freeze({
+      artifact,
+      manifestDigest: `sha256:${createHash("sha256").update(manifestBytes).digest("hex")}`
+    });
+  } finally {
+    manifestBytes?.fill(0);
+    moduleBytes?.fill(0);
+    stylesheetBytes?.fill(0);
+  }
+}
+function probeViteRuntime(loaderUrl) {
+  return loaderUrl === LOADER_URL ? probeLoader(loaderUrl) : Promise.resolve(false);
+}
+async function probeLoader(loaderUrl) {
+  try {
+    const response = await fetch(loaderUrl, {
+      method: "HEAD",
+      cache: "no-store",
+      credentials: "omit",
+      redirect: "error",
+      signal: AbortSignal.timeout(1500)
+    });
+    return response.status === 200 && response.headers.get("content-type")?.toLowerCase().startsWith("application/javascript") === true;
+  } catch {
+    return false;
+  }
+}
+async function secureReadPackageFile(path, maximumBytes) {
+  const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = await handle.stat({ bigint: true });
+    if (!before.isFile() || before.nlink !== 1n || before.uid !== currentUid() || (before.mode & 0o022n) !== 0n || before.size < 1n || before.size > BigInt(maximumBytes)) {
+      throw new Error("package artifact authority is invalid");
+    }
+    const bytes = await handle.readFile();
+    const after = await handle.stat({ bigint: true });
+    if (bytes.byteLength !== Number(before.size) || !sameIdentity(identity(before), identity(after)) || before.mode !== after.mode || before.nlink !== after.nlink || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs) {
+      bytes.fill(0);
+      throw new Error("package artifact changed during secure read");
+    }
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+function packageArtifactPath(root, relativePath) {
+  const path = resolve(root, relativePath);
+  const fromRoot = relative(root, path);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    throw new Error("premium artifact escaped the package root");
+  }
+  return path;
+}
+function containsSourceMapDirective(source) {
+  const normalized = source.toLowerCase();
+  let offset = normalized.indexOf("source");
+  while (offset !== -1) {
+    if (normalized.startsWith("url=", offset + 6) || normalized.charCodeAt(offset + 6) === 109 && normalized.startsWith("appingurl", offset + 7)) {
+      return true;
+    }
+    offset = normalized.indexOf("source", offset + 1);
+  }
+  return false;
+}
+function validatePremiumModuleText(bytes) {
+  const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  if (source.length === 0 || source.includes("\0") || /\bimport(?![A-Za-z0-9_$])/u.test(source) || /\bexport\b[^;]{0,1024}\bfrom\s*["']/u.test(source) || containsSourceMapDirective(source) || /(?:https?:|blob:|data:)/iu.test(source) || /scg-premium-measurement-styles|\[data-scg-premium-measurement|createElement\(["']style["']/u.test(
+    source
+  )) {
+    throw new Error("premium module source is invalid");
+  }
+}
+function validatePremiumStylesheetText(bytes) {
+  const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  if (source.length === 0 || source.includes("\0") || source.split("\n").filter((line) => line.length > 0).length > 1 || containsSourceMapDirective(source) || /@import|url\s*\(|(?:https?:|blob:|data:)/iu.test(source) || !source.includes("[data-scg-premium-measurement=true]") || !/\.scg-meas(?:ure)-layer/u.test(source) || !/\.scg-si(?:ze)-layer/u.test(source)) {
+    throw new Error("premium stylesheet source is invalid");
+  }
+}
+async function secureReadRegularFile(path, maximumBytes, expectedIdentity) {
+  const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = await handle.stat({ bigint: true });
+    if (!before.isFile() || before.uid !== currentUid() || (before.mode & 0o077n) !== 0n || before.size < 1n || before.size > BigInt(maximumBytes) || expectedIdentity !== void 0 && !sameIdentity(identity(before), expectedIdentity)) {
+      throw new Error("runtime file authority is invalid");
+    }
+    const bytes = await handle.readFile();
+    const after = await handle.stat({ bigint: true });
+    if (bytes.byteLength !== Number(before.size) || !sameIdentity(identity(before), identity(after)) || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs) {
+      bytes.fill(0);
+      throw new Error("runtime file changed during secure read");
+    }
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+function parseDescriptor(bytes, rootIdentity, expectedLoaderUrl) {
+  const serialized = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const value = JSON.parse(serialized);
+  const record = exactRecord2(value, DESCRIPTOR_KEYS);
+  if (`${JSON.stringify(record, null, 2)}
+` !== serialized) {
+    throw new Error("descriptor serialization is not canonical");
+  }
+  const approvedRootIdentity = parseIdentity(record.approvedRootIdentity);
+  const authorities = record.credentialAuthorities;
+  const framework = record.framework;
+  const frameworkVersionsValid = framework === "vue3" && isVersion(record.frameworkVersion, 3) && isVersion(record.frameworkPluginVersion, 6) || framework === "react" && isVersion(record.frameworkVersion, 19) && isVersion(record.frameworkPluginVersion, 5);
+  if (record.schemaVersion !== 1 || record.viteVersion !== "7.3.6" || !frameworkVersionsValid || !PROJECT_ID.test(asString(record.projectId)) || record.rootTemplate !== "index.html" || record.loaderUrl !== expectedLoaderUrl || record.host !== "127.0.0.1" || !isValidPort(record.port) || record.credentialProjectId !== record.projectId || record.credentialKey !== "SCENE_GLASS_HOST_TOKEN" || record.navigation !== "spa" || record.readinessPath !== "/__scene-glass/ready" || !sameIdentity(approvedRootIdentity, rootIdentity) || !Array.isArray(authorities) || authorities.length !== 1 || !Object.hasOwn(authorities, 0) || !INSTALL_ID.test(asString(record.installId))) {
+    throw new Error("descriptor authority is invalid");
+  }
+  const authorityRecord = exactRecord2(authorities[0], ["projectId", "path", "device", "inode"]);
+  const authorityDevice = asString(authorityRecord.device);
+  const authorityInode = asString(authorityRecord.inode);
+  const authority = Object.freeze({
+    projectId: asString(authorityRecord.projectId),
+    path: asString(authorityRecord.path),
+    device: authorityDevice,
+    inode: authorityInode
+  });
+  if (authority.projectId !== record.projectId || !isCanonicalAbsolutePath(authority.path) || !isDecimalIdentity(authorityDevice) || !isDecimalIdentity(authorityInode)) {
+    throw new Error("credential authority is invalid");
+  }
+  return Object.freeze({
+    projectId: asString(record.projectId),
+    loaderUrl: expectedLoaderUrl,
+    credentialProjectId: asString(record.credentialProjectId),
+    credentialKey: "SCENE_GLASS_HOST_TOKEN",
+    approvedRootIdentity,
+    credentialAuthority: authority,
+    port: Number(record.port)
+  });
+}
+function parseCredentialToken(bytes, descriptor) {
+  const prefix = `VITE_SCENE_GLASS_LOADER_URL=${descriptor.loaderUrl}
+VITE_SCENE_GLASS_PROJECT_ID=${descriptor.projectId}
+VITE_SCENE_GLASS_PROJECT_TOKEN=`;
+  const suffix = `
+${descriptor.credentialKey}=`;
+  const serialized = bytes.toString("ascii");
+  if (!serialized.startsWith(prefix) || !serialized.endsWith("\n")) {
+    throw new Error("credential envelope is invalid");
+  }
+  const payload = serialized.slice(prefix.length, -1);
+  const separator = payload.indexOf(suffix);
+  if (separator !== 43 || payload.indexOf(suffix, separator + 1) !== -1) {
+    throw new Error("credential envelope is invalid");
+  }
+  const first = payload.slice(0, separator);
+  const second = payload.slice(separator + suffix.length);
+  if (first !== second || !TOKEN.test(first) || !hasCanonicalBase64UrlTail(first)) {
+    throw new Error("credential token is invalid");
+  }
+  return first;
+}
+function hasCanonicalBase64UrlTail(value) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  const finalSextet = alphabet.indexOf(value.at(-1) ?? "");
+  return finalSextet >= 0 && (finalSextet & 3) === 0;
+}
+function exactRecord2(value, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("runtime authority record is invalid");
+  }
+  const prototype = Object.getPrototypeOf(value);
+  const actualKeys = Reflect.ownKeys(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error("runtime authority record is invalid");
+  }
+  if (actualKeys.length !== keys.length || actualKeys.some((key, index) => key !== keys[index])) {
+    throw new Error("runtime authority record is invalid");
+  }
+  const record = {};
+  for (const key of keys) {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (property === void 0 || property.enumerable !== true || !Object.hasOwn(property, "value")) {
+      throw new Error("runtime authority record is invalid");
+    }
+    const propertyValue = property.value;
+    record[key] = propertyValue;
+  }
+  return Object.freeze(record);
+}
+function parseIdentity(value) {
+  const record = exactRecord2(value, ["device", "inode"]);
+  const device = asString(record.device);
+  const inode = asString(record.inode);
+  if (!isDecimalIdentity(device) || !isDecimalIdentity(inode)) {
+    throw new Error("file identity is invalid");
+  }
+  return Object.freeze({ device, inode });
+}
+function isDecimalIdentity(value) {
+  return DECIMAL_IDENTITY.test(value) && BigInt(value) <= 18446744073709551615n;
+}
+function identity(value) {
+  return Object.freeze({ device: String(value.dev), inode: String(value.ino) });
+}
+function sameIdentity(left, right) {
+  return left.device === right.device && left.inode === right.inode;
+}
+function isVersion(value, major) {
+  return typeof value === "string" && new RegExp(`^${major}\\.[0-9]+\\.[0-9]+$`).test(value);
+}
+function isValidPort(value) {
+  return Number.isInteger(value) && Number(value) >= 1024 && Number(value) <= 65535 && value !== 4175;
+}
+function asString(value) {
+  return typeof value === "string" ? value : "";
+}
+function isCanonicalAbsolutePath(value) {
+  if (!isAbsolute(value) || value.includes("\0")) return false;
+  const segments = value.slice(1).split("/");
+  return !segments.some((segment) => segment === "" || segment === "." || segment === "..");
+}
+function currentUid() {
+  const getuid = process.getuid;
+  if (getuid === void 0) throw new Error("owner identity is unavailable");
+  return BigInt(getuid.call(process));
+}
+
+// packages/devtools/src/vite/plugin.ts
+import { createHash as createHash2 } from "node:crypto";
+var PLUGIN_NAME = "scene-glass:dev-only";
+var WARNING = "[scene-glass] runtime unavailable; development injection disabled.";
+var LOADER_MARKER = "data-scg-project=";
+var MAX_LOADER_BYTES = 4 * 1024 * 1024;
+var MAX_MCP_BYTES = 1024 * 1024;
+var JAVASCRIPT_MEDIA_TYPE = "application/javascript; charset=utf-8";
+var SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+var DIAGNOSTIC_SESSION_ID_PATTERN = /^diagnostic-session-[A-Za-z0-9_-]{22}$/u;
+var BROWSER_SESSION_ALIAS_PREFIX = "scene-glass-vite-proxy-v1-";
+var DIAGNOSTIC_ALIAS_HEADER = "x-scene-glass-diagnostic-alias";
+var DIAGNOSTIC_ALIAS_PREFIX = "scene-glass-vite-diagnostic-v1-";
+var DIAGNOSTIC_SESSION_ALIAS_PREFIX = "scene-glass-vite-diagnostic-session-v1-";
+var DIAGNOSTIC_RUN_ID_PATTERN = /^diagnostic-[A-Za-z0-9_-]{22}$/u;
+var MAX_VITE_BROWSER_SESSIONS = 32;
+var SCENE_GLASS_VITE_PATHS = Object.freeze({
+  loader: "/@scene-glass/loader.js",
+  mcp: "/@scene-glass/mcp",
+  diagnosticRuns: "/@scene-glass/diagnostic-runs",
+  premiumMeasurement: "/@scene-glass/premium/measurement-v1.js",
+  premiumMeasurementStylesheet: "/@scene-glass/premium/measurement-v1.css"
+});
+function createSceneGlassPlugin(authoritySource) {
+  let authority;
+  let boundary;
+  let warned = false;
+  return {
+    name: PLUGIN_NAME,
+    apply: "serve",
+    async configureServer(server) {
+      try {
+        const [candidate, premiumArtifact] = await Promise.all([
+          authoritySource.load(server.config.root),
+          loadVitePremiumArtifactAuthority(authoritySource.artifactModuleUrl)
+        ]);
+        if (!await authoritySource.probe(candidate.loaderUrl)) {
+          warnOnce();
+          return;
+        }
+        authority = candidate;
+        boundary = createViteRuntimeBoundary(
+          candidate,
+          premiumArtifact,
+          authoritySource.runtimeOrigin
+        );
+        server.middlewares.use((request, response, next) => {
+          const activeBoundary = boundary;
+          if (activeBoundary?.handles(request.url) === true) {
+            void activeBoundary.handle(request, response).catch(() => {
+              if (!response.headersSent) sendEmpty(response, 503);
+              else response.destroy();
+            });
+            return;
+          }
+          if (isHtmlNavigation(request.url, request.headers.accept)) {
+            const setHeader = response.setHeader.bind(response);
+            response.setHeader = (name, value) => setHeader(name, name.toLowerCase() === "cache-control" ? "no-store" : value);
+            response.setHeader("Cache-Control", "no-store");
+            if (hasInitialCouponQuery(request.url)) {
+              response.setHeader("Referrer-Policy", "no-referrer");
+            }
+          }
+          next();
+        });
+      } catch {
+        authority = void 0;
+        boundary = void 0;
+        warnOnce();
+      }
+      function warnOnce() {
+        if (warned) return;
+        warned = true;
+        server.config.logger.warn(WARNING);
+      }
+    },
+    transformIndexHtml(html) {
+      if (authority === void 0 || alreadyInjected(html)) {
+        return html;
+      }
+      const referrerPolicy = {
+        tag: "meta",
+        attrs: {
+          name: "referrer",
+          content: "no-referrer"
+        },
+        injectTo: "head-prepend"
+      };
+      const loader = {
+        tag: "script",
+        attrs: {
+          src: SCENE_GLASS_VITE_PATHS.loader,
+          referrerpolicy: "no-referrer",
+          "data-scg-project": authority.projectId,
+          "data-scg-navigation": "spa"
+        },
+        injectTo: "head-prepend"
+      };
+      return { html, tags: [referrerPolicy, loader] };
+    }
+  };
+}
+function createViteRuntimeBoundary(authority, premiumAuthority, runtimeOrigin) {
+  const artifact = premiumAuthority.artifact;
+  let activeSessionId = null;
+  let activeSessionAlias = null;
+  let nextSessionAlias = 0;
+  let nextDiagnosticAlias = 0;
+  let nextDiagnosticSessionAlias = 0;
+  const sessionIds = /* @__PURE__ */ new Map();
+  const diagnosticAuthorities = /* @__PURE__ */ new Map();
+  const diagnosticSessions = /* @__PURE__ */ new Map();
+  const projectPath = encodeURIComponent(authority.projectId);
+  const upstream = Object.freeze({
+    loader: authority.loaderUrl,
+    mcp: `${runtimeOrigin}/mcp/v1/projects/${projectPath}`,
+    diagnosticRuns: `${runtimeOrigin}/mcp/v1/projects/${projectPath}/diagnostic-runs`,
+    premiumMeasurement: `${runtimeOrigin}/${artifact.module.path}`,
+    premiumMeasurementStylesheet: `${runtimeOrigin}/${artifact.stylesheet.path}`
+  });
+  const removeDiagnosticAuthority = (diagnosticAlias) => {
+    diagnosticAuthorities.delete(diagnosticAlias);
+    for (const [sessionAlias, session] of diagnosticSessions) {
+      if (session.diagnosticAlias === diagnosticAlias) diagnosticSessions.delete(sessionAlias);
+    }
+  };
+  const pruneDiagnosticAuthorities = () => {
+    const now = Date.now();
+    for (const [diagnosticAlias, diagnosticAuthority] of diagnosticAuthorities) {
+      if (diagnosticAuthority.expiresAt <= now) removeDiagnosticAuthority(diagnosticAlias);
+    }
+  };
+  const handleMainMcp = async (request, response) => {
+    const browserSession = singleHeader(request.headers["mcp-session-id"]);
+    const upstreamSessionId = browserSession === void 0 ? void 0 : sessionIds.get(browserSession);
+    if (browserSession !== void 0 && upstreamSessionId === void 0 || browserSession === void 0 && request.method === "DELETE" || browserSession === void 0 && sessionIds.size >= MAX_VITE_BROWSER_SESSIONS) {
+      sendEmpty(response, 404);
+      return;
+    }
+    const responseSessionAlias = browserSession ?? `${BROWSER_SESSION_ALIAS_PREFIX}${String(++nextSessionAlias)}`;
+    const nextSession = await proxyJsonRequest({
+      request,
+      response,
+      target: upstream.mcp,
+      token: authority.token,
+      origin: authority.origin,
+      responseSessionAlias,
+      ...upstreamSessionId === void 0 ? {} : { upstreamSessionId }
+    });
+    if (nextSession !== void 0) {
+      sessionIds.set(responseSessionAlias, nextSession);
+      activeSessionAlias = responseSessionAlias;
+      activeSessionId = nextSession;
+    }
+    if (request.method === "DELETE" && browserSession !== void 0 && response.statusCode >= 200 && response.statusCode < 300) {
+      sessionIds.delete(browserSession);
+      if (activeSessionAlias === browserSession) {
+        const fallback = [...sessionIds.entries()].at(-1);
+        activeSessionAlias = fallback?.[0] ?? null;
+        activeSessionId = fallback?.[1] ?? null;
+      }
+    }
+  };
+  const handleDiagnosticMcp = async (request, response, diagnosticAlias) => {
+    pruneDiagnosticAuthorities();
+    const diagnosticAuthority = diagnosticAuthorities.get(diagnosticAlias);
+    const browserSession = singleHeader(request.headers["mcp-session-id"]);
+    const diagnosticSession = browserSession === void 0 ? void 0 : diagnosticSessions.get(browserSession);
+    if (diagnosticAuthority === void 0 || browserSession !== void 0 && (diagnosticSession === void 0 || diagnosticSession.diagnosticAlias !== diagnosticAlias) || browserSession === void 0 && request.method === "DELETE" || browserSession === void 0 && diagnosticSessions.size >= MAX_VITE_BROWSER_SESSIONS) {
+      sendEmpty(response, 404);
+      return;
+    }
+    const responseSessionAlias = browserSession ?? `${DIAGNOSTIC_SESSION_ALIAS_PREFIX}${String(++nextDiagnosticSessionAlias)}`;
+    const nextSession = await proxyJsonRequest({
+      request,
+      response,
+      target: upstream.mcp,
+      token: diagnosticAuthority.token,
+      origin: authority.origin,
+      responseSessionAlias,
+      ...diagnosticSession === void 0 ? {} : { upstreamSessionId: diagnosticSession.upstreamSessionId },
+      upstreamSessionIdPattern: DIAGNOSTIC_SESSION_ID_PATTERN
+    });
+    if (nextSession !== void 0) {
+      diagnosticSessions.set(
+        responseSessionAlias,
+        Object.freeze({ diagnosticAlias, upstreamSessionId: nextSession })
+      );
+    }
+    if (request.method === "DELETE" && browserSession !== void 0 && response.statusCode >= 200 && response.statusCode < 300) {
+      removeDiagnosticAuthority(diagnosticAlias);
+    }
+  };
+  return Object.freeze({
+    handles(url) {
+      return typeof url === "string" && url.startsWith("/@scene-glass/");
+    },
+    async handle(request, response) {
+      const path = exactRequestPath(request.url);
+      if (path === void 0 || !hasBrowserAuthority(request, authority, path)) {
+        sendEmpty(response, 404);
+        return;
+      }
+      if (path === SCENE_GLASS_VITE_PATHS.loader) {
+        await serveLoader(request, response, upstream.loader);
+        return;
+      }
+      if (path === SCENE_GLASS_VITE_PATHS.mcp) {
+        const rawDiagnosticAlias = request.headers[DIAGNOSTIC_ALIAS_HEADER];
+        const diagnosticAlias = singleHeader(rawDiagnosticAlias);
+        if (rawDiagnosticAlias !== void 0 && diagnosticAlias === void 0) {
+          sendEmpty(response, 404);
+          return;
+        }
+        if (diagnosticAlias === void 0) await handleMainMcp(request, response);
+        else await handleDiagnosticMcp(request, response, diagnosticAlias);
+        return;
+      }
+      if (path === SCENE_GLASS_VITE_PATHS.diagnosticRuns) {
+        pruneDiagnosticAuthorities();
+        if (diagnosticAuthorities.size >= MAX_VITE_BROWSER_SESSIONS) {
+          sendEmpty(response, 429);
+          return;
+        }
+        const diagnosticAlias = `${DIAGNOSTIC_ALIAS_PREFIX}${String(++nextDiagnosticAlias)}`;
+        const issued = await issueDiagnosticRun({
+          alias: diagnosticAlias,
+          browserMcpEndpoint: `${authority.origin}${SCENE_GLASS_VITE_PATHS.mcp}`,
+          origin: authority.origin,
+          request,
+          response,
+          target: upstream.diagnosticRuns,
+          token: authority.token,
+          upstreamMcpEndpoint: upstream.mcp
+        });
+        if (issued !== void 0) diagnosticAuthorities.set(diagnosticAlias, issued);
+        return;
+      }
+      if (path === SCENE_GLASS_VITE_PATHS.premiumMeasurement || path === SCENE_GLASS_VITE_PATHS.premiumMeasurementStylesheet) {
+        if (request.method !== "GET" || activeSessionId === null) {
+          sendEmpty(response, 404);
+          return;
+        }
+        const moduleRequest = path === SCENE_GLASS_VITE_PATHS.premiumMeasurement;
+        await servePremiumArtifact({
+          artifact: moduleRequest ? artifact.module : artifact.stylesheet,
+          kind: moduleRequest ? "module" : "stylesheet",
+          manifestDigest: premiumAuthority.manifestDigest,
+          premium: artifact,
+          origin: authority.origin,
+          projectId: authority.projectId,
+          request,
+          response,
+          sessionId: activeSessionId,
+          target: moduleRequest ? upstream.premiumMeasurement : upstream.premiumMeasurementStylesheet,
+          token: authority.token
+        });
+        return;
+      }
+      sendEmpty(response, 404);
+    }
+  });
+}
+function exactRequestPath(url) {
+  if (url === void 0 || url.includes("?") || url.includes("#")) return void 0;
+  try {
+    const parsed = new URL(url, "http://127.0.0.1");
+    return parsed.pathname === url ? parsed.pathname : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hasBrowserAuthority(request, authority, path) {
+  if (singleHeader(request.headers.host) !== authority.origin.slice("http://".length) || request.headers.authorization !== void 0 || request.headers["x-scene-glass-project-id"] !== void 0 || path !== SCENE_GLASS_VITE_PATHS.mcp && request.headers[DIAGNOSTIC_ALIAS_HEADER] !== void 0) {
+    return false;
+  }
+  if (path === SCENE_GLASS_VITE_PATHS.loader && (request.method === "GET" || request.method === "HEAD")) {
+    return true;
+  }
+  const origin = singleHeader(request.headers.origin);
+  const referer = singleHeader(request.headers.referer);
+  const fetchSite = singleHeader(request.headers["sec-fetch-site"]);
+  const noReferrerPremiumFetch = (path === SCENE_GLASS_VITE_PATHS.premiumMeasurement || path === SCENE_GLASS_VITE_PATHS.premiumMeasurementStylesheet) && origin === void 0 && referer === void 0 && fetchSite === "same-origin" && singleHeader(request.headers["sec-fetch-mode"]) === "cors" && singleHeader(request.headers["sec-fetch-dest"]) === "empty";
+  return noReferrerPremiumFetch || (origin === authority.origin || referer?.startsWith(`${authority.origin}/`) === true) && (fetchSite === void 0 || fetchSite === "same-origin");
+}
+async function serveLoader(request, response, target) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    sendEmpty(response, 405);
+    return;
+  }
+  const controller = requestAbortController(request, response);
+  const upstream = await fetch(target, {
+    method: request.method,
+    cache: "no-store",
+    credentials: "omit",
+    redirect: "error",
+    signal: controller.signal
+  });
+  if (upstream.status !== 200 || !upstream.ok || upstream.redirected || upstream.url !== target || upstream.headers.get("content-type") !== JAVASCRIPT_MEDIA_TYPE) {
+    await cancelBody(upstream);
+    sendEmpty(response, 503);
+    return;
+  }
+  const bytes = request.method === "HEAD" ? Buffer.alloc(0) : await readBoundedResponse(upstream, MAX_LOADER_BYTES, false);
+  response.statusCode = 200;
+  response.setHeader("cache-control", "no-store");
+  response.setHeader("content-type", JAVASCRIPT_MEDIA_TYPE);
+  response.setHeader("x-content-type-options", "nosniff");
+  if (request.method === "HEAD") {
+    response.end();
+    return;
+  }
+  response.setHeader("content-length", String(bytes.byteLength));
+  sendBytes(response, bytes);
+}
+async function proxyJsonRequest(input) {
+  const method = input.request.method;
+  if (method !== "POST" && method !== "DELETE") {
+    sendEmpty(input.response, 405);
+    return void 0;
+  }
+  const body = method === "POST" ? await readBoundedRequest(input.request, MAX_MCP_BYTES) : void 0;
+  const requestBody = body === void 0 ? void 0 : new Uint8Array(body);
+  const controller = requestAbortController(input.request, input.response);
+  try {
+    const headers = {
+      accept: singleHeader(input.request.headers.accept) ?? "application/json",
+      authorization: `Bearer ${input.token}`,
+      origin: input.origin
+    };
+    copyRequestHeader(input.request, headers, "content-type");
+    copyRequestHeader(input.request, headers, "mcp-protocol-version");
+    if (input.upstreamSessionId !== void 0) {
+      headers["mcp-session-id"] = input.upstreamSessionId;
+    }
+    const upstream = await fetch(input.target, {
+      method,
+      cache: "no-store",
+      credentials: "omit",
+      headers,
+      redirect: "error",
+      signal: controller.signal,
+      ...requestBody === void 0 ? {} : { body: requestBody }
+    });
+    if (upstream.redirected || upstream.url !== input.target) {
+      await cancelBody(upstream);
+      sendEmpty(input.response, 502);
+      return void 0;
+    }
+    const bytes = await readBoundedResponse(upstream, MAX_MCP_BYTES, true);
+    input.response.statusCode = upstream.status;
+    for (const name of ["cache-control", "content-type", "www-authenticate"]) {
+      const value = upstream.headers.get(name);
+      if (value !== null) input.response.setHeader(name, value);
+    }
+    const sessionId = upstream.headers.get("mcp-session-id");
+    const validSessionId = sessionId !== null && (input.upstreamSessionIdPattern ?? SESSION_ID_PATTERN).test(sessionId) ? sessionId : void 0;
+    if (input.responseSessionAlias !== void 0 && validSessionId !== void 0) {
+      input.response.setHeader("mcp-session-id", input.responseSessionAlias);
+    }
+    sendBytes(input.response, bytes);
+    return validSessionId;
+  } finally {
+    requestBody?.fill(0);
+    body?.fill(0);
+  }
+}
+async function issueDiagnosticRun(input) {
+  if (input.request.method !== "POST") {
+    sendEmpty(input.response, 405);
+    return void 0;
+  }
+  const body = await readBoundedRequest(input.request, MAX_MCP_BYTES);
+  const requestBody = new Uint8Array(body);
+  const controller = requestAbortController(input.request, input.response);
+  let responseBytes;
+  try {
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${input.token}`,
+      origin: input.origin
+    };
+    copyRequestHeader(input.request, headers, "content-type");
+    const upstream = await fetch(input.target, {
+      method: "POST",
+      cache: "no-store",
+      credentials: "omit",
+      headers,
+      redirect: "error",
+      signal: controller.signal,
+      body: requestBody
+    });
+    if (upstream.redirected || upstream.url !== input.target) {
+      await cancelBody(upstream);
+      sendEmpty(input.response, 502);
+      return void 0;
+    }
+    responseBytes = await readBoundedResponse(upstream, MAX_MCP_BYTES, true);
+    if (upstream.status !== 201) {
+      sendEmpty(input.response, upstream.status);
+      return void 0;
+    }
+    if (upstream.headers.get("content-type")?.toLowerCase().startsWith("application/json") !== true || upstream.headers.get("cache-control")?.split(",").some((directive) => directive.trim().toLowerCase() === "no-store") !== true) {
+      sendEmpty(input.response, 502);
+      return void 0;
+    }
+    const issued = parseDiagnosticAuthorityResponse(responseBytes, input.upstreamMcpEndpoint);
+    const rewritten = Buffer.from(
+      JSON.stringify({
+        runId: issued.runId,
+        token: input.alias,
+        expiresAt: issued.expiresAt,
+        endpoint: input.browserMcpEndpoint
+      }),
+      "utf8"
+    );
+    input.response.statusCode = 201;
+    input.response.setHeader("cache-control", "private, no-store");
+    input.response.setHeader("content-length", String(rewritten.byteLength));
+    input.response.setHeader("content-type", "application/json; charset=utf-8");
+    input.response.setHeader("x-content-type-options", "nosniff");
+    sendBytes(input.response, rewritten);
+    return Object.freeze({ expiresAt: Date.parse(issued.expiresAt), token: issued.token });
+  } finally {
+    responseBytes?.fill(0);
+    requestBody.fill(0);
+    body.fill(0);
+  }
+}
+function parseDiagnosticAuthorityResponse(bytes, upstreamMcpEndpoint) {
+  const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  if (!isRecord2(value)) throw new Error("diagnostic authority response is invalid");
+  const record = value;
+  const keys = Reflect.ownKeys(record);
+  const expiresAt = typeof record.expiresAt === "string" ? record.expiresAt : "";
+  const expiresAtTimestamp = Date.parse(expiresAt);
+  if (keys.length !== 4 || !["runId", "token", "expiresAt", "endpoint"].every((key) => keys.includes(key)) || typeof record.runId !== "string" || !DIAGNOSTIC_RUN_ID_PATTERN.test(record.runId) || typeof record.token !== "string" || !isCanonicalBearer(record.token) || !Number.isSafeInteger(expiresAtTimestamp) || expiresAtTimestamp <= Date.now() || new Date(expiresAtTimestamp).toISOString() !== expiresAt || record.endpoint !== upstreamMcpEndpoint) {
+    throw new Error("diagnostic authority response is invalid");
+  }
+  return Object.freeze({
+    endpoint: upstreamMcpEndpoint,
+    expiresAt,
+    runId: record.runId,
+    token: record.token
+  });
+}
+function isCanonicalBearer(value) {
+  if (!SESSION_ID_PATTERN.test(value)) return false;
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  const finalSextet = alphabet.indexOf(value.at(-1) ?? "");
+  return finalSextet >= 0 && (finalSextet & 3) === 0;
+}
+async function servePremiumArtifact(input) {
+  const controller = requestAbortController(input.request, input.response);
+  const upstream = await fetch(input.target, {
+    cache: "no-store",
+    credentials: "omit",
+    headers: {
+      accept: input.kind === "module" ? "application/javascript" : "text/css",
+      authorization: `Bearer ${input.token}`,
+      "mcp-session-id": input.sessionId,
+      origin: input.origin,
+      "x-scene-glass-project-id": input.projectId
+    },
+    redirect: "error",
+    signal: controller.signal
+  });
+  if (!validPremiumResponse(upstream, input)) {
+    await cancelBody(upstream);
+    sendEmpty(input.response, 502);
+    return;
+  }
+  const bytes = await readBoundedResponse(upstream, input.artifact.maxBytes, false);
+  try {
+    const declaredLength = upstream.headers.get("content-length");
+    if (declaredLength !== null && declaredLength !== String(bytes.byteLength) || `sha256:${createHash2("sha256").update(bytes).digest("hex")}` !== input.artifact.sha256) {
+      bytes.fill(0);
+      sendEmpty(input.response, 502);
+      return;
+    }
+    if (input.kind === "module") validatePremiumModuleText2(bytes);
+    else validatePremiumStylesheetText2(bytes);
+    input.response.statusCode = 200;
+    input.response.setHeader("cache-control", "private, no-store");
+    input.response.setHeader("content-length", String(bytes.byteLength));
+    input.response.setHeader("content-type", input.artifact.mediaType);
+    input.response.setHeader("x-content-type-options", "nosniff");
+    input.response.setHeader("x-scene-glass-artifact-path", input.artifact.path);
+    input.response.setHeader("x-scene-glass-content-sha256", input.artifact.sha256);
+    input.response.setHeader("x-scene-glass-module-abi", String(input.premium.abiVersion));
+    input.response.setHeader("x-scene-glass-module-id", input.premium.moduleId);
+    input.response.setHeader("x-scene-glass-module-namespace", input.premium.namespace);
+    input.response.setHeader("x-scene-glass-release-manifest-sha256", input.manifestDigest);
+    sendBytes(input.response, bytes);
+  } catch {
+    bytes.fill(0);
+    if (!input.response.headersSent) sendEmpty(input.response, 502);
+    else input.response.destroy();
+  }
+}
+function validPremiumResponse(response, input) {
+  const length = response.headers.get("content-length");
+  return response.status === 200 && response.ok && !response.redirected && response.url === input.target && response.headers.get("content-type") === input.artifact.mediaType && response.headers.get("x-scene-glass-artifact-path") === input.artifact.path && response.headers.get("x-scene-glass-module-id") === input.premium.moduleId && response.headers.get("x-scene-glass-module-abi") === String(input.premium.abiVersion) && response.headers.get("x-scene-glass-module-namespace") === input.premium.namespace && response.headers.get("x-scene-glass-content-sha256") === input.artifact.sha256 && response.headers.get("x-scene-glass-release-manifest-sha256") === input.manifestDigest && (length === null || /^[1-9][0-9]*$/u.test(length) && Number(length) <= input.artifact.maxBytes);
+}
+function containsSourceMapDirective2(source) {
+  const normalized = source.toLowerCase();
+  let offset = normalized.indexOf("source");
+  while (offset !== -1) {
+    if (normalized.startsWith("url=", offset + 6) || normalized.charCodeAt(offset + 6) === 109 && normalized.startsWith("appingurl", offset + 7)) {
+      return true;
+    }
+    offset = normalized.indexOf("source", offset + 1);
+  }
+  return false;
+}
+function validatePremiumModuleText2(bytes) {
+  const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  if (source.length === 0 || source.includes("\0") || /\bimport(?![A-Za-z0-9_$])/u.test(source) || /\bexport\b[^;]{0,1024}\bfrom\s*["']/u.test(source) || containsSourceMapDirective2(source) || /(?:https?:|blob:|data:)/iu.test(source) || /scg-premium-measurement-styles|\[data-scg-premium-measurement|createElement\(["']style["']/u.test(
+    source
+  )) {
+    throw new Error("premium module source is invalid");
+  }
+}
+function validatePremiumStylesheetText2(bytes) {
+  const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  if (source.length === 0 || source.includes("\0") || source.split("\n").filter((line) => line.length > 0).length > 1 || containsSourceMapDirective2(source) || /@import|url\s*\(|(?:https?:|blob:|data:)/iu.test(source) || !source.includes("[data-scg-premium-measurement=true]") || !/\.scg-meas(?:ure)-layer/u.test(source) || !/\.scg-si(?:ze)-layer/u.test(source)) {
+    throw new Error("premium stylesheet source is invalid");
+  }
+}
+async function readBoundedRequest(request, maximum) {
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const value of request) {
+      const chunk = requestChunk(value);
+      chunks.push(chunk);
+      total += chunk.byteLength;
+      if (chunk.byteLength === 0 || total > maximum) throw new Error("request body is invalid");
+    }
+    if (total === 0) throw new Error("request body is empty");
+    return Buffer.concat(chunks, total);
+  } finally {
+    for (const chunk of chunks) chunk.fill(0);
+  }
+}
+function requestChunk(value) {
+  if (Buffer.isBuffer(value)) return value;
+  if (typeof value === "string" || value instanceof Uint8Array) return Buffer.from(value);
+  throw new Error("request body is invalid");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readBoundedResponse(response, maximum, allowEmpty) {
+  if (response.body === null) {
+    if (allowEmpty) return Buffer.alloc(0);
+    throw new Error("response body is empty");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const item = await reader.read();
+      if (item.done) break;
+      const chunk = item.value;
+      chunks.push(chunk);
+      total += chunk.byteLength;
+      if (chunk.byteLength === 0 || total > maximum) throw new Error("response body is invalid");
+    }
+    if (!allowEmpty && total === 0) throw new Error("response body is empty");
+    const bytes = Buffer.alloc(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  } finally {
+    for (const chunk of chunks) chunk.fill(0);
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    reader.releaseLock();
+  }
+}
+function requestAbortController(request, response) {
+  const controller = new AbortController();
+  request.once("aborted", () => controller.abort());
+  response.once("close", () => {
+    if (!response.writableEnded) controller.abort();
+  });
+  return controller;
+}
+function copyRequestHeader(request, target, name) {
+  const value = singleHeader(request.headers[name]);
+  if (value !== void 0) target[name] = value;
+}
+function singleHeader(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function sendBytes(response, bytes) {
+  let cleared = false;
+  const clear = () => {
+    if (cleared) return;
+    cleared = true;
+    bytes.fill(0);
+  };
+  response.once("close", clear);
+  try {
+    response.end(bytes, clear);
+  } catch (error) {
+    clear();
+    throw error;
+  }
+}
+function sendEmpty(response, status) {
+  response.statusCode = status;
+  response.removeHeader("content-type");
+  response.setHeader("cache-control", "no-store");
+  response.setHeader("content-length", "0");
+  response.end();
+}
+async function cancelBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+  }
+}
+function alreadyInjected(html) {
+  return html.includes(`src="${SCENE_GLASS_VITE_PATHS.loader}"`) && html.includes(LOADER_MARKER);
+}
+function hasInitialCouponQuery(url) {
+  if (url === void 0) return false;
+  try {
+    return new URL(url, "http://127.0.0.1").searchParams.has("scg-coupon");
+  } catch {
+    return false;
+  }
+}
+function isHtmlNavigation(url, accept) {
+  if (url === void 0) return false;
+  const pathname = url.split("?", 1)[0] ?? "";
+  return accept?.toLowerCase().includes("text/html") === true || pathname === "/" || pathname.endsWith(".html");
+}
+
+// packages/devtools/src/vite.ts
+var LOOPBACK_RUNTIME_ORIGIN = "http://127.0.0.1:4175";
+function sceneGlass() {
+  return createSceneGlassPlugin({
+    artifactModuleUrl: import.meta.url,
+    load: loadViteRuntimeAuthority,
+    probe: probeViteRuntime,
+    runtimeOrigin: LOOPBACK_RUNTIME_ORIGIN
+  });
+}
+export {
+  SCENE_GLASS_VITE_PATHS,
+  sceneGlass
+};