@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-ZZ7RO2UQ.js

@@ -0,0 +1,1243 @@
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+import path from 'path';
+
+var DEFAULT_STDLIB_POLICY = {
+  allowedPaths: ["compositions", "data", "src", "packages"],
+  maxFileBytes: 2 * 1024 * 1024,
+  allowShell: false,
+  allowedShellCommands: [],
+  maxShellOutputBytes: 100 * 1024,
+  shellTimeoutMs: 6e4,
+  allowNetwork: false,
+  allowedHosts: [],
+  rootDir: ".",
+  allowMediaDecode: false,
+  allowDepthInference: false,
+  allowGpuCompute: false,
+  allowDeviceProbe: false,
+  allowedDeviceScopes: [],
+  deviceProbeTimeoutMs: 1e4,
+  allowDeviceRead: false,
+  allowDevicePair: false,
+  allowDeviceCommand: false,
+  allowHaptic: false,
+  allowXrSession: false,
+  allowSensorRead: false,
+  maxGifFrames: 500,
+  maxVideoDurationSec: 300,
+  maxMediaResolution: 4096
+};
+function resolveRepoRelativePath(targetPath, rootDir) {
+  const normalized = targetPath.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+  if (!normalized) return { ok: false, error: "Path is required" };
+  const abs = path.resolve(rootDir, normalized);
+  const rel = path.relative(rootDir, abs).replace(/\\/g, "/");
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+    return { ok: false, error: "Path escapes repository root" };
+  }
+  return { ok: true, rel, abs };
+}
+function isPathAllowed(relPath, allowedRoots) {
+  const normalized = relPath.replace(/\\/g, "/");
+  return allowedRoots.some((root) => normalized === root || normalized.startsWith(`${root}/`));
+}
+function parseHostFromUrl(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function truncateText(value, max) {
+  const str = typeof value === "string" ? value : String(value ?? "");
+  if (!Number.isFinite(max) || max <= 0 || str.length <= max) return str;
+  return `${str.slice(0, max)}
+...[truncated ${str.length - max} chars]`;
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+}
+function resolveInto(params, defaultPrefix) {
+  return typeof params.into === "string" && params.into.trim().length > 0 ? params.into.trim() : defaultPrefix;
+}
+function createStdlibActions(options) {
+  const { policy, hostCapabilities: caps, debug } = options;
+  const log = debug ? (msg) => console.log(`  [stdlib] ${msg}`) : () => {
+  };
+  return {
+    // ── File System ──────────────────────────────────────────────────────
+    fs_read: async (params, bb) => {
+      const prefix = resolveInto(params, "fs_read");
+      const filePath = typeof params.path === "string" ? params.path : "";
+      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
+      if (!resolved.ok) {
+        bb[`${prefix}_error`] = resolved.error;
+        return false;
+      }
+      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
+        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
+        return false;
+      }
+      if (!caps?.fileSystem) {
+        bb[`${prefix}_error`] = "fileSystem capability not available";
+        return false;
+      }
+      const exists = caps.fileSystem.exists ? await Promise.resolve(caps.fileSystem.exists(resolved.rel)) : true;
+      if (!exists) {
+        bb[`${prefix}_error`] = `file not found: ${resolved.rel}`;
+        bb[`${prefix}_exists`] = false;
+        return false;
+      }
+      const content = await Promise.resolve(caps.fileSystem.readFile(resolved.rel));
+      if (Buffer.byteLength(content, "utf-8") > policy.maxFileBytes) {
+        bb[`${prefix}_error`] = `file exceeds max size (${policy.maxFileBytes} bytes)`;
+        return false;
+      }
+      bb[`${prefix}_content`] = content;
+      bb[`${prefix}_exists`] = true;
+      log(`fs_read: ${resolved.rel} (${Buffer.byteLength(content, "utf-8")} bytes)`);
+      return true;
+    },
+    fs_write: async (params, bb) => {
+      const prefix = resolveInto(params, "fs_write");
+      const filePath = typeof params.path === "string" ? params.path : "";
+      const content = typeof params.content === "string" ? params.content : null;
+      const append = params.append === true;
+      if (content === null) {
+        bb[`${prefix}_error`] = "content is required";
+        return false;
+      }
+      if (Buffer.byteLength(content, "utf-8") > policy.maxFileBytes) {
+        bb[`${prefix}_error`] = `content exceeds max size (${policy.maxFileBytes} bytes)`;
+        return false;
+      }
+      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
+      if (!resolved.ok) {
+        bb[`${prefix}_error`] = resolved.error;
+        return false;
+      }
+      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
+        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
+        return false;
+      }
+      if (!caps?.fileSystem) {
+        bb[`${prefix}_error`] = "fileSystem capability not available";
+        return false;
+      }
+      let finalContent = content;
+      if (append && caps.fileSystem.exists) {
+        const exists = await Promise.resolve(caps.fileSystem.exists(resolved.rel));
+        if (exists) {
+          const current = await Promise.resolve(caps.fileSystem.readFile(resolved.rel));
+          finalContent = `${current}${content}`;
+        }
+      }
+      await Promise.resolve(caps.fileSystem.writeFile(resolved.rel, finalContent));
+      bb[`${prefix}_path`] = resolved.rel;
+      bb[`${prefix}_bytes`] = Buffer.byteLength(content, "utf-8");
+      log(`fs_write: ${resolved.rel} (${bb[`${prefix}_bytes`]} bytes, append=${append})`);
+      return true;
+    },
+    fs_exists: async (params, bb) => {
+      const prefix = resolveInto(params, "fs_exists");
+      const filePath = typeof params.path === "string" ? params.path : "";
+      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
+      if (!resolved.ok) {
+        bb[`${prefix}_error`] = resolved.error;
+        return false;
+      }
+      if (!caps?.fileSystem?.exists) {
+        bb[`${prefix}_error`] = "fileSystem.exists capability not available";
+        return false;
+      }
+      const exists = await Promise.resolve(caps.fileSystem.exists(resolved.rel));
+      bb[`${prefix}_exists`] = exists;
+      log(`fs_exists: ${resolved.rel} \u2192 ${exists}`);
+      return true;
+    },
+    fs_delete: async (params, bb) => {
+      const prefix = resolveInto(params, "fs_delete");
+      const filePath = typeof params.path === "string" ? params.path : "";
+      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
+      if (!resolved.ok) {
+        bb[`${prefix}_error`] = resolved.error;
+        return false;
+      }
+      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
+        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
+        return false;
+      }
+      if (!caps?.fileSystem?.deleteFile) {
+        bb[`${prefix}_error`] = "fileSystem.deleteFile capability not available";
+        return false;
+      }
+      await Promise.resolve(caps.fileSystem.deleteFile(resolved.rel));
+      log(`fs_delete: ${resolved.rel}`);
+      return true;
+    },
+    // ── Process Execution ─────────────────────────────────────────────────
+    process_exec: async (params, bb) => {
+      const prefix = resolveInto(params, "process_exec");
+      if (!policy.allowShell) {
+        bb[`${prefix}_error`] = `${prefix} is disabled by policy`;
+        return false;
+      }
+      const command = typeof params.cmd === "string" ? params.cmd.trim() : "";
+      const args = toStringArray(params.args);
+      if (!command) {
+        bb[`${prefix}_error`] = "cmd is required";
+        return false;
+      }
+      if (policy.allowedShellCommands.length > 0) {
+        const executable = command.split(/\s+/)[0].toLowerCase();
+        const allowed = policy.allowedShellCommands.some((c) => c.toLowerCase() === executable);
+        if (!allowed) {
+          bb[`${prefix}_error`] = `command "${executable}" is not allowlisted`;
+          return false;
+        }
+      }
+      if (!caps?.process?.exec) {
+        bb[`${prefix}_error`] = "process.exec capability not available";
+        return false;
+      }
+      const timeoutMs = typeof params.timeout === "number" && Number.isFinite(params.timeout) ? Math.max(1e3, Math.min(policy.shellTimeoutMs, Math.floor(params.timeout))) : policy.shellTimeoutMs;
+      const cwd = typeof params.cwd === "string" ? params.cwd : policy.rootDir;
+      const result = await Promise.resolve(caps.process.exec(command, args, { cwd, timeoutMs }));
+      bb[`${prefix}_code`] = result.code ?? -1;
+      bb[`${prefix}_stdout`] = truncateText(result.stdout, policy.maxShellOutputBytes);
+      bb[`${prefix}_stderr`] = truncateText(result.stderr, policy.maxShellOutputBytes);
+      log(`process_exec: ${command} ${args.join(" ")} \u2192 code ${result.code}`);
+      return result.code === 0;
+    },
+    // ── Network ───────────────────────────────────────────────────────────
+    // ── Media Decode ──────────────────────────────────────────────────────
+    media_decode: async (params, bb) => {
+      const prefix = resolveInto(params, "media_decode");
+      if (!policy.allowMediaDecode) {
+        bb[`${prefix}_error`] = "media_decode is disabled by policy (allowMediaDecode=false)";
+        return false;
+      }
+      if (!caps?.media?.decodeFrames) {
+        bb[`${prefix}_error`] = "media.decodeFrames capability not available";
+        return false;
+      }
+      const source = params.source;
+      if (typeof source !== "string" && !(source instanceof ArrayBuffer)) {
+        bb[`${prefix}_error`] = "source (URL string or ArrayBuffer) is required";
+        return false;
+      }
+      const maxFrames = typeof params.maxFrames === "number" ? Math.min(params.maxFrames, policy.maxGifFrames ?? 500) : policy.maxGifFrames ?? 500;
+      const mediaType = params.type === "video" ? "video" : "gif";
+      try {
+        const frames = await caps.media.decodeFrames(source, {
+          maxFrames,
+          type: mediaType
+        });
+        bb[`${prefix}_frames`] = frames;
+        bb[`${prefix}_count`] = frames.length;
+        log(`media_decode: decoded ${frames.length} frames (type=${mediaType})`);
+        return true;
+      } catch (error) {
+        bb[`${prefix}_error`] = error.message;
+        return false;
+      }
+    },
+    // ── Depth Inference ───────────────────────────────────────────────────
+    depth_inference: async (params, bb) => {
+      const prefix = resolveInto(params, "depth_inference");
+      if (!policy.allowDepthInference) {
+        bb[`${prefix}_error`] = "depth_inference is disabled by policy (allowDepthInference=false)";
+        return false;
+      }
+      if (!caps?.depthInference?.estimateDepth) {
+        bb[`${prefix}_error`] = "depthInference.estimateDepth capability not available";
+        return false;
+      }
+      const source = params.source;
+      if (typeof source !== "string" && !(source instanceof ArrayBuffer)) {
+        bb[`${prefix}_error`] = "source (image URL string or ArrayBuffer) is required";
+        return false;
+      }
+      const maxRes = policy.maxMediaResolution ?? 4096;
+      const width = typeof params.width === "number" ? Math.min(params.width, maxRes) : void 0;
+      const height = typeof params.height === "number" ? Math.min(params.height, maxRes) : void 0;
+      const modelId = typeof params.modelId === "string" ? params.modelId : void 0;
+      try {
+        const depthMap = await caps.depthInference.estimateDepth(source, {
+          width,
+          height,
+          modelId
+        });
+        bb[`${prefix}_data`] = depthMap.data;
+        bb[`${prefix}_width`] = depthMap.width;
+        bb[`${prefix}_height`] = depthMap.height;
+        bb[`${prefix}_backend`] = depthMap.backend;
+        bb[`${prefix}_inferenceMs`] = depthMap.inferenceMs;
+        log(
+          `depth_inference: ${depthMap.width}\xD7${depthMap.height} via ${depthMap.backend} (${depthMap.inferenceMs}ms)`
+        );
+        return true;
+      } catch (error) {
+        bb[`${prefix}_error`] = error.message;
+        return false;
+      }
+    },
+    // ── GPU Compute ───────────────────────────────────────────────────────
+    gpu_compute: async (params, bb) => {
+      const prefix = resolveInto(params, "gpu_compute");
+      if (!policy.allowGpuCompute) {
+        bb[`${prefix}_error`] = "gpu_compute is disabled by policy (allowGpuCompute=false)";
+        return false;
+      }
+      if (!caps?.gpuCompute?.dispatch) {
+        bb[`${prefix}_error`] = "gpuCompute.dispatch capability not available";
+        return false;
+      }
+      const shader = typeof params.shader === "string" ? params.shader.trim() : "";
+      if (!shader) {
+        bb[`${prefix}_error`] = "shader (WGSL source) is required";
+        return false;
+      }
+      const inputs = {};
+      if (typeof params.inputs === "object" && params.inputs !== null) {
+        for (const [k, v] of Object.entries(params.inputs)) {
+          if (v instanceof ArrayBuffer) inputs[k] = v;
+        }
+      }
+      const rawWg = params.workgroups;
+      const workgroups = Array.isArray(rawWg) ? [rawWg[0], rawWg[1], rawWg[2]] : [1];
+      try {
+        const result = await caps.gpuCompute.dispatch(shader, inputs, workgroups);
+        bb[`${prefix}_outputs`] = result.outputs;
+        bb[`${prefix}_dispatchMs`] = result.dispatchMs;
+        log(`gpu_compute: dispatch completed in ${result.dispatchMs}ms`);
+        return true;
+      } catch (error) {
+        bb[`${prefix}_error`] = error.message;
+        return false;
+      }
+    },
+    // ── Target Device Probe ───────────────────────────────────────────────
+    device_probe: async (params, bb) => {
+      const prefix = resolveInto(params, "device_probe");
+      if (!policy.allowDeviceProbe) {
+        bb[`${prefix}_error`] = "device_probe is disabled by policy (allowDeviceProbe=false)";
+        return false;
+      }
+      const scope = typeof params.scope === "string" ? params.scope.trim() : "";
+      if (!scope) {
+        bb[`${prefix}_error`] = "scope is required";
+        return false;
+      }
+      const allowedScopes = policy.allowedDeviceScopes ?? [];
+      if (!allowedScopes.includes(scope)) {
+        bb[`${prefix}_error`] = `device scope "${scope}" is not allowlisted`;
+        bb[`${prefix}_denial_receipt`] = {
+          scope,
+          reason: "scope_not_allowlisted",
+          policy: "allowedDeviceScopes",
+          deniedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return false;
+      }
+      const scopeGateMap = {
+        allowDeviceRead: policy.allowDeviceRead,
+        allowDevicePair: policy.allowDevicePair,
+        allowDeviceCommand: policy.allowDeviceCommand,
+        allowHaptic: policy.allowHaptic,
+        allowXrSession: policy.allowXrSession,
+        allowSensorRead: policy.allowSensorRead
+      };
+      if (scope in scopeGateMap && scopeGateMap[scope] === false) {
+        bb[`${prefix}_error`] = `device scope "${scope}" is denied by policy (${scope}=false)`;
+        bb[`${prefix}_denial_receipt`] = {
+          scope,
+          reason: "scope_gate_denied",
+          policy: scope,
+          deniedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return false;
+      }
+      if (!caps?.deviceProbe?.probe || !caps.deviceProbe.available) {
+        bb[`${prefix}_error`] = "deviceProbe capability not available";
+        return false;
+      }
+      const timeoutPolicyMs = policy.deviceProbeTimeoutMs ?? 1e4;
+      const timeoutMs = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs) ? Math.max(250, Math.min(timeoutPolicyMs, Math.floor(params.timeoutMs))) : timeoutPolicyMs;
+      try {
+        const result = await caps.deviceProbe.probe({
+          scope,
+          targetId: typeof params.targetId === "string" ? params.targetId : void 0,
+          targetKind: typeof params.targetKind === "string" ? params.targetKind : void 0,
+          timeoutMs,
+          metadata: typeof params.metadata === "object" && params.metadata !== null ? params.metadata : void 0
+        });
+        bb[`${prefix}_ok`] = result.ok;
+        bb[`${prefix}_status`] = result.status;
+        bb[`${prefix}_deviceId`] = result.deviceId;
+        bb[`${prefix}_targetKind`] = result.targetKind;
+        bb[`${prefix}_detail`] = result.detail;
+        bb[`${prefix}_metrics`] = result.metrics;
+        bb[`${prefix}_receipt`] = result.receipt;
+        log(`device_probe: ${scope} \u2192 ${result.status}`);
+        return result.ok;
+      } catch (error) {
+        bb[`${prefix}_error`] = error.message;
+        return false;
+      }
+    },
+    net_fetch: async (params, bb) => {
+      const prefix = resolveInto(params, "net_fetch");
+      const url = typeof params.url === "string" ? params.url.trim() : "";
+      if (!url) {
+        bb[`${prefix}_error`] = "url is required";
+        return false;
+      }
+      if (!policy.allowNetwork) {
+        bb[`${prefix}_error`] = "network access is disabled by policy";
+        return false;
+      }
+      const hostName = parseHostFromUrl(url);
+      if (!hostName) {
+        bb[`${prefix}_error`] = "invalid url";
+        return false;
+      }
+      if (policy.allowedHosts.length > 0) {
+        const allowed = policy.allowedHosts.includes(hostName) || policy.allowedHosts.some((h) => hostName.endsWith(`.${h}`));
+        if (!allowed) {
+          bb[`${prefix}_error`] = `host "${hostName}" is not allowlisted`;
+          return false;
+        }
+      }
+      if (caps?.network?.fetch) {
+        try {
+          const response = await Promise.resolve(
+            caps.network.fetch(url, {
+              method: typeof params.method === "string" ? params.method : "GET",
+              headers: typeof params.headers === "object" && params.headers ? params.headers : void 0,
+              body: typeof params.body === "string" ? params.body : void 0
+            })
+          );
+          bb[`${prefix}_status`] = response.status;
+          bb[`${prefix}_body`] = truncateText(response.text ?? "", policy.maxShellOutputBytes);
+          bb[`${prefix}_ok`] = response.ok;
+          log(`net_fetch: ${url} \u2192 ${response.status}`);
+          return response.ok;
+        } catch (error) {
+          bb[`${prefix}_error`] = error.message;
+          return false;
+        }
+      }
+      try {
+        const response = await globalThis.fetch(url, {
+          method: typeof params.method === "string" ? params.method : "GET",
+          headers: typeof params.headers === "object" && params.headers ? params.headers : void 0
+        });
+        const text = await response.text();
+        bb[`${prefix}_status`] = response.status;
+        bb[`${prefix}_body`] = truncateText(text, policy.maxShellOutputBytes);
+        bb[`${prefix}_ok`] = response.ok;
+        log(`net_fetch: ${url} \u2192 ${response.status}`);
+        return response.ok;
+      } catch (error) {
+        bb[`${prefix}_error`] = error.message;
+        return false;
+      }
+    }
+  };
+}
+function registerStdlib(runtime, options) {
+  const actions = createStdlibActions(options);
+  for (const [name, handler] of Object.entries(actions)) {
+    runtime.registerAction(name, handler);
+  }
+}
+
+// src/stdlib/PermissionScopePolicy.ts
+function normalizePermissionScopeName(scope) {
+  return scope.trim().toLowerCase();
+}
+function isValidPermissionScopeName(scope) {
+  if (typeof scope !== "string") return false;
+  const normalized = normalizePermissionScopeName(scope);
+  return normalized.length > 0 && !/[\u0000-\u001f\s]/.test(normalized);
+}
+function normalizedScopeNames(scopes) {
+  return new Set(
+    scopes.map((scope) => normalizePermissionScopeName(scope.scope)).filter((scope) => scope.length > 0)
+  );
+}
+function invalidScopeNames(scopes) {
+  return scopes.map((scope) => scope.scope).filter((scope) => !isValidPermissionScopeName(scope));
+}
+function invalidNeverScopeNames(neverScopes) {
+  return neverScopes.filter((scope) => !isValidPermissionScopeName(scope));
+}
+function forbiddenScopeReason(scope, neverScopes) {
+  const normalized = normalizePermissionScopeName(scope);
+  const explicitNever = neverScopes.map(normalizePermissionScopeName);
+  if (explicitNever.includes(normalized)) return "is listed in neverScopes";
+  if (normalized === "*" || normalized.includes("*")) return "uses a wildcard";
+  if (/\b(admin|billing|owner|delete|full_access|write_all|manage_all)\b/.test(normalized)) {
+    return "requests broad administrative authority";
+  }
+  return void 0;
+}
+function evaluateStdlibPermissionScopePolicy(scope, neverScopes = []) {
+  const normalizedScope = normalizePermissionScopeName(scope);
+  const reason = isValidPermissionScopeName(scope) ? forbiddenScopeReason(scope, neverScopes) : "is empty or contains whitespace/control characters";
+  return {
+    scope,
+    normalizedScope,
+    allowed: !reason,
+    ...reason ? { reason } : {}
+  };
+}
+function findMissingRequiredPermissionScopes(requiredScopes, candidateScopes) {
+  const candidateNames = normalizedScopeNames(candidateScopes);
+  return requiredScopes.filter((scope) => scope.required === true).map((scope) => scope.scope).filter((scope) => !candidateNames.has(normalizePermissionScopeName(scope)));
+}
+function findExtraPermissionScopes(grantedScopes, minimumRequiredScopes) {
+  const minimumNames = normalizedScopeNames(minimumRequiredScopes);
+  return grantedScopes.map((scope) => scope.scope).filter((scope) => !minimumNames.has(normalizePermissionScopeName(scope)));
+}
+function buildStdlibPermissionScopeDiff(input) {
+  const requested = input.requestedScopes ?? [];
+  const minimum = input.minimumRequiredScopes ?? [];
+  const granted = input.grantedScopes ?? [];
+  const neverScopes = input.neverScopes ?? [];
+  const invalidRequestedScopes = invalidScopeNames(requested);
+  const invalidMinimumRequiredScopes = invalidScopeNames(minimum);
+  const invalidGrantedScopes = invalidScopeNames(granted);
+  const invalidNeverScopes = invalidNeverScopeNames(neverScopes);
+  const missingRequestedRequiredScopes = findMissingRequiredPermissionScopes(minimum, requested);
+  const missingGrantedRequiredScopes = findMissingRequiredPermissionScopes(minimum, granted);
+  const extraGrantedScopes = findExtraPermissionScopes(granted, minimum);
+  const forbiddenRequestedScopes = requested.map((scope) => evaluateStdlibPermissionScopePolicy(scope.scope, neverScopes)).filter((scope) => !scope.allowed);
+  const forbiddenGrantedScopes = granted.map((scope) => evaluateStdlibPermissionScopePolicy(scope.scope, neverScopes)).filter((scope) => !scope.allowed);
+  const policyInputValid = invalidRequestedScopes.length === 0 && invalidMinimumRequiredScopes.length === 0 && invalidGrantedScopes.length === 0 && invalidNeverScopes.length === 0;
+  return {
+    requestedScopes: requested.map((scope) => scope.scope),
+    minimumRequiredScopes: minimum.map((scope) => scope.scope),
+    grantedScopes: granted.map((scope) => scope.scope),
+    invalidRequestedScopes,
+    invalidMinimumRequiredScopes,
+    invalidGrantedScopes,
+    invalidNeverScopes,
+    missingRequestedRequiredScopes,
+    missingGrantedRequiredScopes,
+    extraGrantedScopes,
+    forbiddenRequestedScopes,
+    forbiddenGrantedScopes,
+    minimumScopeSatisfied: policyInputValid && missingRequestedRequiredScopes.length === 0 && missingGrantedRequiredScopes.length === 0 && forbiddenRequestedScopes.length === 0 && forbiddenGrantedScopes.length === 0,
+    excessScopesAbsent: extraGrantedScopes.length === 0,
+    policyInputValid
+  };
+}
+function redactStdlibPermissionPreview(value) {
+  const original = value ?? "";
+  let preview = original;
+  let absolutePathRedacted = false;
+  let credentialMaterialRedacted = false;
+  preview = preview.replace(
+    /(^|[\s"'`=])(?:[A-Za-z]:[\\/]|\/(?!\/)[^\s"'`]+)/g,
+    (match, prefix) => {
+      absolutePathRedacted = true;
+      return `${prefix}<absolute-path-redacted>`;
+    }
+  );
+  preview = preview.replace(
+    /\b(access_token|refresh_token|id_token|client_secret|authorization|cookie|code)=([^&\s]+)/gi,
+    (_match, key, secret) => {
+      if (secret === "<redacted>") return `${key}=<redacted>`;
+      credentialMaterialRedacted = true;
+      return `${key}=<redacted>`;
+    }
+  );
+  preview = preview.replace(
+    /\bBearer\s+([A-Za-z0-9._~+/=-]+|<redacted>)/gi,
+    (_match, secret) => {
+      if (secret === "<redacted>") return "Bearer <redacted>";
+      credentialMaterialRedacted = true;
+      return "Bearer <redacted>";
+    }
+  );
+  return {
+    preview,
+    redacted: preview !== original,
+    absolutePathRedacted,
+    credentialMaterialRedacted
+  };
+}
+function stdlibPermissionPreviewHasPublicLeak(value) {
+  const redaction = redactStdlibPermissionPreview(value);
+  return redaction.absolutePathRedacted || redaction.credentialMaterialRedacted;
+}
+
+// src/traits/TestTrait.ts
+init_safeJsonParse();
+var CompositionTestRunner = class {
+  constructor(initialState, computedDefs = [], config = {}) {
+    this.initialState = { ...initialState };
+    this.computedDefs = computedDefs;
+    this.config = {
+      bail: config.bail ?? false,
+      debug: config.debug ?? false,
+      timeout: config.timeout ?? 5e3
+    };
+  }
+  /**
+   * Extract and run all @test blocks from .hsplus source
+   */
+  runTestsFromSource(source) {
+    const tests = this.extractTestBlocks(source);
+    if (this.config.debug) {
+      console.debug(`[composition_test] Found ${tests.length} @test blocks`);
+    }
+    return this.runAll(tests);
+  }
+  /**
+   * Run all test blocks
+   */
+  runAll(tests) {
+    const results = [];
+    for (const test of tests) {
+      if (test.skip) {
+        results.push({
+          name: test.name,
+          status: "skipped",
+          durationMs: 0,
+          assertions: test.assertions.length,
+          passedAssertions: 0
+        });
+        continue;
+      }
+      const result = this.runSingle(test);
+      results.push(result);
+      if (this.config.bail && result.status === "failed") {
+        break;
+      }
+    }
+    return results;
+  }
+  /**
+   * Run a single test block:
+   * 1. Clone initial state
+   * 2. Apply setup assignments
+   * 3. Evaluate computed values
+   * 4. Check assertions
+   */
+  runSingle(test) {
+    const start = Date.now();
+    let passedAssertions = 0;
+    try {
+      const state = { ...this.initialState };
+      for (const { variable, expression } of test.setupAssignments) {
+        const value = this.evaluateValue(expression, state);
+        state[variable] = value;
+      }
+      const computed = this.evaluateComputedValues(state);
+      const fullState = { ...state, ...computed };
+      if (this.config.debug) {
+        console.debug(`[composition_test] "${test.name}" state:`, fullState);
+      }
+      for (const assertion of test.assertions) {
+        const passed = this.evaluateAssertion(assertion.expression, fullState);
+        if (passed) {
+          passedAssertions++;
+        } else {
+          return {
+            name: test.name,
+            status: "failed",
+            durationMs: Date.now() - start,
+            error: `Assertion failed: ${assertion.expression}`,
+            assertions: test.assertions.length,
+            passedAssertions
+          };
+        }
+      }
+      return {
+        name: test.name,
+        status: "passed",
+        durationMs: Date.now() - start,
+        assertions: test.assertions.length,
+        passedAssertions
+      };
+    } catch (error) {
+      return {
+        name: test.name,
+        status: "failed",
+        durationMs: Date.now() - start,
+        error: error instanceof Error ? error.message : String(error),
+        assertions: test.assertions.length,
+        passedAssertions
+      };
+    }
+  }
+  // ─── Extraction ──────────────────────────────────────────────────────────────
+  /**
+   * Extract @test { name: "...", setup: { ... }, assert: { ... } } blocks
+   */
+  extractTestBlocks(source) {
+    const blocks = [];
+    const regex = /@test\s*\{/g;
+    let match;
+    while ((match = regex.exec(source)) !== null) {
+      const startIdx = match.index + match[0].length;
+      let depth = 1;
+      let endIdx = startIdx;
+      while (depth > 0 && endIdx < source.length) {
+        if (source[endIdx] === "{") depth++;
+        if (source[endIdx] === "}") depth--;
+        endIdx++;
+      }
+      const body = source.substring(startIdx, endIdx - 1).trim();
+      const block = this.parseTestBody(body);
+      if (block) blocks.push(block);
+    }
+    return blocks;
+  }
+  /**
+   * Parse the body of a @test block into structured data
+   */
+  parseTestBody(body) {
+    const nameMatch = body.match(/name:\s*"([^"]+)"/);
+    if (!nameMatch) return null;
+    const name = nameMatch[1];
+    const skipMatch = body.match(/skip:\s*(true|false)/);
+    const skip = skipMatch?.[1] === "true";
+    const setupAssignments = [];
+    const setupMatch = body.match(/setup:\s*\{([^}]+)\}/);
+    if (setupMatch) {
+      const setupBody = setupMatch[1].trim();
+      const assignRegex = /\$([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)/g;
+      let assignMatch;
+      while ((assignMatch = assignRegex.exec(setupBody)) !== null) {
+        setupAssignments.push({
+          variable: assignMatch[1],
+          expression: assignMatch[2].trim().replace(/[,;]\s*$/, "")
+        });
+      }
+    }
+    const assertions = [];
+    const assertRegex = /assert:\s*\{([^}]+)\}/g;
+    let assertMatch;
+    while ((assertMatch = assertRegex.exec(body)) !== null) {
+      const assertBody = assertMatch[1].trim();
+      const lines = assertBody.split(/[;\n]/).map((l) => l.trim()).filter(Boolean);
+      for (const line of lines) {
+        assertions.push({ expression: line });
+      }
+    }
+    return { name, setupAssignments, assertions, skip };
+  }
+  // ─── Evaluation ──────────────────────────────────────────────────────────────
+  /**
+   * Evaluate a single value expression, resolving $vars from state
+   */
+  evaluateValue(expr, state) {
+    const trimmed = expr.trim();
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "null") return null;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    if (trimmed.startsWith("$")) {
+      const varName = trimmed.slice(1);
+      return state[varName];
+    }
+    try {
+      const transformed = trimmed.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, varName) => varName);
+      const keys = Object.keys(state);
+      const values = Object.values(state);
+      const fn = new Function(
+        ...keys,
+        "Math",
+        "String",
+        "Number",
+        "Boolean",
+        "Date",
+        "JSON",
+        `"use strict"; return (${transformed})`
+      );
+      return fn(...values, Math, String, Number, Boolean, Date, JSON);
+    } catch {
+      return trimmed;
+    }
+  }
+  /**
+   * Evaluate an assertion expression against state.
+   * Supports: $var == value, $var != value, $var > value, etc.
+   */
+  evaluateAssertion(expr, state) {
+    const trimmed = expr.trim();
+    const transformed = trimmed.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, varName) => varName);
+    try {
+      const keys = Object.keys(state);
+      const values = Object.values(state);
+      const fn = new Function(
+        ...keys,
+        "Math",
+        "String",
+        "Number",
+        "Boolean",
+        "Date",
+        "JSON",
+        `"use strict"; return !!(${transformed})`
+      );
+      return fn(...values, Math, String, Number, Boolean, Date, JSON);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Evaluate computed values from their definitions
+   */
+  evaluateComputedValues(state) {
+    const result = {};
+    for (const def of this.computedDefs) {
+      try {
+        const transformed = def.expression.replace(
+          /\$([a-zA-Z_][a-zA-Z0-9_]*)/g,
+          (_, varName) => varName
+        );
+        const keys = Object.keys(state);
+        const values = Object.values(state);
+        const fn = new Function(
+          ...keys,
+          "Math",
+          "String",
+          "Number",
+          "Boolean",
+          "Date",
+          "JSON",
+          `"use strict"; return (${transformed})`
+        );
+        result[def.name] = fn(...values, Math, String, Number, Boolean, Date, JSON);
+      } catch {
+        result[def.name] = void 0;
+      }
+    }
+    return result;
+  }
+  // ─── Static helpers ──────────────────────────────────────────────────────────
+  /**
+   * Extract state block from .hsplus source.
+   * Handles nested objects { ... } and arrays [ ... ].
+   */
+  static extractStateFromSource(source) {
+    const result = {};
+    const stateMatch = source.match(/\bstate\s*\{/);
+    if (stateMatch) {
+      const startIdx = stateMatch.index + stateMatch[0].length;
+      const body = extractBracedBody(source, startIdx);
+      Object.assign(result, parseNestedBlock(body));
+    }
+    const inlineRegex = /^\s*state\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\w+\s*=\s*(.+)$/gm;
+    let inlineMatch;
+    while ((inlineMatch = inlineRegex.exec(source)) !== null) {
+      const key = inlineMatch[1];
+      if (!(key in result)) {
+        result[key] = parseStateValue(inlineMatch[2].trim());
+      }
+    }
+    return result;
+  }
+  /**
+   * Extract computed definitions from .hsplus source
+   */
+  static extractComputedFromSource(source) {
+    const defs = [];
+    const computedMatch = source.match(/\bcomputed\s*\{/);
+    if (!computedMatch) return defs;
+    const startIdx = computedMatch.index + computedMatch[0].length;
+    let depth = 1;
+    let endIdx = startIdx;
+    while (depth > 0 && endIdx < source.length) {
+      if (source[endIdx] === "{") depth++;
+      if (source[endIdx] === "}") depth--;
+      endIdx++;
+    }
+    const body = source.substring(startIdx, endIdx - 1);
+    const lines = body.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//")) continue;
+      const kvMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?)\s*$/);
+      if (kvMatch) {
+        defs.push({ name: kvMatch[1], expression: kvMatch[2] });
+      }
+    }
+    return defs;
+  }
+};
+function extractBracedBody(source, startIdx) {
+  let depth = 1;
+  let i = startIdx;
+  while (depth > 0 && i < source.length) {
+    if (source[i] === "{") depth++;
+    if (source[i] === "}") depth--;
+    i++;
+  }
+  return source.substring(startIdx, i - 1);
+}
+function parseNestedBlock(body) {
+  const result = {};
+  let i = 0;
+  while (i < body.length) {
+    while (i < body.length && /\s/.test(body[i])) i++;
+    if (i >= body.length) break;
+    if (body[i] === "/" && body[i + 1] === "/") {
+      while (i < body.length && body[i] !== "\n") i++;
+      continue;
+    }
+    const keyMatch = body.slice(i).match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    i += keyMatch[0].length;
+    while (i < body.length && /\s/.test(body[i])) i++;
+    if (body[i] === "{") {
+      i++;
+      const nestedBody = extractBracedBody(body, i);
+      i += nestedBody.length + 1;
+      result[key] = parseNestedBlock(nestedBody);
+    } else if (body[i] === "[") {
+      const arrStart = i;
+      let depth = 1;
+      i++;
+      while (depth > 0 && i < body.length) {
+        if (body[i] === "[") depth++;
+        if (body[i] === "]") depth--;
+        i++;
+      }
+      const arrStr = body.substring(arrStart, i).trim();
+      try {
+        result[key] = readJson(arrStr);
+      } catch {
+        result[key] = arrStr;
+      }
+    } else {
+      const valMatch = body.slice(i).match(/^(.+?)(?:\n|$)/);
+      if (valMatch) {
+        const raw = valMatch[1].trim().replace(/,\s*$/, "");
+        result[key] = parseStateValue(raw);
+        i += valMatch[0].length;
+      } else {
+        i++;
+      }
+    }
+  }
+  return result;
+}
+function parseStateValue(raw) {
+  const v = raw.trim().replace(/,\s*$/, "");
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+  if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1);
+  }
+  return v;
+}
+var TEST_TRAIT = {
+  name: "test",
+  category: "testing",
+  description: "Native composition testing with $stateVar syntax",
+  compileTargets: ["node", "python", "ros2", "headless"],
+  requiresRenderer: false,
+  parameters: [
+    { name: "name", type: "string", required: true, description: "Test name" },
+    { name: "setup", type: "object", required: false, description: "State setup assignments" },
+    { name: "assert", type: "object", required: true, description: "Assertion expressions" },
+    {
+      name: "skip",
+      type: "boolean",
+      required: false,
+      default: false,
+      description: "Skip this test"
+    }
+  ]
+};
+var testHandler = {
+  name: "test",
+  defaultConfig: { bail: false, debug: false, timeout: 5e3 },
+  onAttach(node, config, ctx) {
+    const instance = new CompositionTestRunner({}, [], config);
+    node.__test_instance = instance;
+    ctx.emit?.("test:attached", { node, config });
+  },
+  onDetach(node, _config, ctx) {
+    delete node.__test_instance;
+    ctx.emit?.("test:detached", { node });
+  },
+  onUpdate() {
+  },
+  onEvent(node, _config, ctx, event) {
+    const instance = node.__test_instance;
+    if (!instance) return;
+    const eventType = typeof event === "string" ? event : event.type;
+    if (eventType === "test:run" && event.source) {
+      const results = instance.runTestsFromSource(event.source);
+      ctx.emit?.("test:results", { results });
+    }
+  }
+};
+
+// src/deploy/license-checker.ts
+var RESTRICTIVENESS = {
+  free: 0,
+  cc_by: 1,
+  cc_by_sa: 2,
+  cc_by_nc: 3,
+  commercial: 4,
+  exclusive: 5
+};
+function checkLicenseCompatibility(compositionLicense, importedLicenses) {
+  const errors = [];
+  const warnings = [];
+  let forcedLicense;
+  if (importedLicenses.length === 0) {
+    return { compatible: true, errors: [], warnings: [] };
+  }
+  for (const imp of importedLicenses) {
+    if (imp.license === "exclusive") {
+      errors.push(
+        `Cannot import "${imp.path}" \u2014 license is "exclusive" (view-only, no import allowed)`
+      );
+      continue;
+    }
+    if (imp.license === "commercial") {
+      warnings.push(
+        `Import "${imp.path}" has "commercial" license \u2014 ensure purchase is verified before publishing`
+      );
+      continue;
+    }
+    if (imp.license === "cc_by_sa") {
+      const compositionLevel = RESTRICTIVENESS[compositionLicense];
+      const requiredLevel = RESTRICTIVENESS.cc_by_sa;
+      if (compositionLevel < requiredLevel) {
+        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < requiredLevel) {
+          forcedLicense = "cc_by_sa";
+        }
+        warnings.push(
+          `Import "${imp.path}" is "cc_by_sa" \u2014 your composition license forced to "cc_by_sa" (share-alike)`
+        );
+      }
+    }
+    if (imp.license === "cc_by_nc") {
+      if (compositionLicense === "free" || compositionLicense === "cc_by") {
+        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < RESTRICTIVENESS.cc_by_nc) {
+          forcedLicense = "cc_by_nc";
+        }
+        warnings.push(
+          `Import "${imp.path}" is "cc_by_nc" \u2014 your composition license forced to "cc_by_nc" (non-commercial)`
+        );
+      }
+    }
+    if (imp.license === "cc_by") {
+      if (compositionLicense === "free") {
+        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < RESTRICTIVENESS.cc_by) {
+          forcedLicense = "cc_by";
+        }
+        warnings.push(
+          `Import "${imp.path}" is "cc_by" \u2014 your composition license forced to at least "cc_by" (attribution required)`
+        );
+      }
+    }
+  }
+  const hasShareAlike = importedLicenses.some((i) => i.license === "cc_by_sa");
+  const hasNonCommercial = importedLicenses.some((i) => i.license === "cc_by_nc");
+  if (hasShareAlike && hasNonCommercial) {
+    errors.push(
+      'License conflict: cannot mix "cc_by_sa" (share-alike) and "cc_by_nc" (non-commercial) imports \u2014 cc_by_sa requires derivatives use the same license, but cc_by_nc requires non-commercial use'
+    );
+  }
+  return {
+    compatible: errors.length === 0,
+    errors,
+    warnings,
+    forcedLicense
+  };
+}
+
+// src/deploy/protocol-types.ts
+var PROTOCOL_CONSTANTS = {
+  /** Platform fee in basis points (2.5%) */
+  PLATFORM_FEE_BPS: 250,
+  /** Import royalty per level in basis points (5% per level) */
+  IMPORT_ROYALTY_BPS: 500,
+  /** Maximum import depth for revenue distribution */
+  MAX_IMPORT_DEPTH: 3,
+  /** Default referral reward in basis points (2%) */
+  DEFAULT_REFERRAL_BPS: 200,
+  /** Basis points denominator */
+  BPS_DENOMINATOR: 1e4,
+  /** Zora mint fee per edition (in wei) */
+  ZORA_MINT_FEE_WEI: 777000000000000n,
+  // 0.000777 ETH
+  /** Chain configuration */
+  CHAIN: {
+    id: 8453,
+    name: "base",
+    testnet: {
+      id: 84532,
+      name: "base-sepolia"
+    }
+  },
+  /** Protocol registry base URL */
+  REGISTRY_BASE_URL: "https://holoscript.net",
+  /** Zora 1155 factory address (same on all chains) */
+  ZORA_1155_FACTORY: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
+  /** Environment variable names */
+  ENV: {
+    WALLET_KEY: "HOLOSCRIPT_WALLET_KEY",
+    COLLECTION_ADDRESS: "HOLOSCRIPT_COLLECTION_ADDRESS",
+    SERVER_URL: "HOLOSCRIPT_SERVER_URL"
+  }
+};
+
+// src/deploy/revenue-splitter.ts
+function calculateRevenueDistribution(collectPrice, creator, importChain, options = {}) {
+  const {
+    platformFeeBps = PROTOCOL_CONSTANTS.PLATFORM_FEE_BPS,
+    importRoyaltyBps = PROTOCOL_CONSTANTS.IMPORT_ROYALTY_BPS,
+    maxImportDepth = PROTOCOL_CONSTANTS.MAX_IMPORT_DEPTH,
+    referralBps = PROTOCOL_CONSTANTS.DEFAULT_REFERRAL_BPS,
+    referrer,
+    platformAddress = "platform"
+  } = options;
+  const flows = [];
+  if (collectPrice === 0n) {
+    return { totalPrice: 0n, flows: [] };
+  }
+  const bpsDenom = BigInt(PROTOCOL_CONSTANTS.BPS_DENOMINATOR);
+  let remaining = collectPrice;
+  const platformFee = collectPrice * BigInt(platformFeeBps) / bpsDenom;
+  if (platformFee > 0n) {
+    flows.push({
+      recipient: platformAddress,
+      amount: platformFee,
+      reason: "platform",
+      bps: platformFeeBps
+    });
+    remaining -= platformFee;
+  }
+  if (referrer) {
+    const referralAmount = collectPrice * BigInt(referralBps) / bpsDenom;
+    if (referralAmount > 0n) {
+      flows.push({
+        recipient: referrer,
+        amount: referralAmount,
+        reason: "referral",
+        bps: referralBps
+      });
+      remaining -= referralAmount;
+    }
+  }
+  const flattenedByDepth = flattenImportsByDepth(importChain, maxImportDepth);
+  for (const [depth, nodes] of flattenedByDepth.entries()) {
+    if (nodes.length === 0) continue;
+    const levelRoyalty = collectPrice * BigInt(importRoyaltyBps) / bpsDenom;
+    const perImportRoyalty = levelRoyalty / BigInt(nodes.length);
+    const dust = levelRoyalty - perImportRoyalty * BigInt(nodes.length);
+    for (let i = 0; i < nodes.length; i++) {
+      const amount = i === 0 ? perImportRoyalty + dust : perImportRoyalty;
+      if (amount > 0n) {
+        flows.push({
+          recipient: nodes[i].author,
+          amount,
+          reason: "import_royalty",
+          depth,
+          bps: Math.floor(importRoyaltyBps / nodes.length)
+        });
+        remaining -= amount;
+      }
+    }
+  }
+  if (remaining > 0n) {
+    const creatorBps = PROTOCOL_CONSTANTS.BPS_DENOMINATOR - platformFeeBps - (referrer ? referralBps : 0) - importRoyaltyBps * flattenedByDepth.size;
+    flows.push({
+      recipient: creator,
+      amount: remaining,
+      reason: "creator",
+      bps: Math.max(creatorBps, 0)
+    });
+  }
+  return { totalPrice: collectPrice, flows };
+}
+function flattenImportsByDepth(chain, maxDepth) {
+  const byDepth = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  function walk(nodes, depth) {
+    if (depth > maxDepth) return;
+    for (const node of nodes) {
+      if (seen.has(node.contentHash)) continue;
+      seen.add(node.contentHash);
+      const list = byDepth.get(depth) ?? [];
+      list.push(node);
+      byDepth.set(depth, list);
+      if (node.children.length > 0) {
+        walk(node.children, depth + 1);
+      }
+    }
+  }
+  walk(chain, 1);
+  return byDepth;
+}
+async function resolveImportChain(imports, resolver, maxDepth = PROTOCOL_CONSTANTS.MAX_IMPORT_DEPTH) {
+  const seen = /* @__PURE__ */ new Set();
+  async function resolve(importList, depth) {
+    if (depth > maxDepth) return [];
+    const nodes = [];
+    for (const imp of importList) {
+      const hash = imp.hash;
+      if (!hash || seen.has(hash)) continue;
+      seen.add(hash);
+      const record = await resolver(hash);
+      const author = record?.author ?? imp.author ?? "unknown";
+      const children = record && depth < maxDepth ? await resolve(
+        record.importHashes.map((h) => ({ hash: h, path: "", author: "" })),
+        depth + 1
+      ) : [];
+      nodes.push({
+        contentHash: hash,
+        author,
+        depth,
+        children
+      });
+    }
+    return nodes;
+  }
+  return resolve(imports, 1);
+}
+function formatRevenueDistribution(dist) {
+  if (dist.totalPrice === 0n) return ["Free collect \u2014 no revenue distribution"];
+  return dist.flows.map((flow) => {
+    const pct = (Number(flow.amount) / Number(dist.totalPrice) * 100).toFixed(1);
+    const depthLabel = flow.depth ? `, depth ${flow.depth}` : "";
+    return `${pct}% \u2192 ${flow.recipient} (${flow.reason}${depthLabel})`;
+  });
+}
+function ethToWei(eth) {
+  const parts = eth.split(".");
+  const whole = parts[0] || "0";
+  const fraction = (parts[1] || "").padEnd(18, "0").slice(0, 18);
+  return BigInt(whole) * 10n ** 18n + BigInt(fraction);
+}
+function weiToEth(wei) {
+  const str = wei.toString().padStart(19, "0");
+  const whole = str.slice(0, str.length - 18) || "0";
+  const fraction = str.slice(str.length - 18).replace(/0+$/, "") || "0";
+  return `${whole}.${fraction}`;
+}
+
+export { CompositionTestRunner, DEFAULT_STDLIB_POLICY, PROTOCOL_CONSTANTS, TEST_TRAIT, buildStdlibPermissionScopeDiff, calculateRevenueDistribution, checkLicenseCompatibility, createStdlibActions, ethToWei, evaluateStdlibPermissionScopePolicy, findExtraPermissionScopes, findMissingRequiredPermissionScopes, formatRevenueDistribution, isPathAllowed, isValidPermissionScopeName, normalizePermissionScopeName, parseHostFromUrl, redactStdlibPermissionPreview, registerStdlib, resolveImportChain, resolveRepoRelativePath, stdlibPermissionPreviewHasPublicLeak, testHandler, toStringArray, truncateText, weiToEth };
+//# sourceMappingURL=chunk-ZZ7RO2UQ.js.map
+//# sourceMappingURL=chunk-ZZ7RO2UQ.js.map