@holoscript/core 6.0.4 → 6.1.2

package/dist/{chunk-DMG7C4H2.js → chunk-ZZ7RO2UQ.js}

@@ -1,7 +1,6 @@
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
 import path from 'path';
-import { createHash } from 'crypto';
 
-// src/stdlib/StdlibActions.ts
 var DEFAULT_STDLIB_POLICY = {
   allowedPaths: ["compositions", "data", "src", "packages"],
   maxFileBytes: 2 * 1024 * 1024,
@@ -15,6 +14,15 @@ var DEFAULT_STDLIB_POLICY = {
   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
@@ -203,6 +211,182 @@ function createStdlibActions(options) {
       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() : "";
@@ -270,7 +454,129 @@ function registerStdlib(runtime, options) {
   }
 }
 
+// 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 };
@@ -612,7 +918,7 @@ function parseNestedBlock(body) {
       }
       const arrStr = body.substring(arrStart, i).trim();
       try {
-        result[key] = JSON.parse(arrStr);
+        result[key] = readJson(arrStr);
       } catch {
         result[key] = arrStr;
       }
@@ -683,44 +989,6 @@ var testHandler = {
     }
   }
 };
-function computeContentHash(source) {
-  const normalized = source.replace(/\r\n/g, "\n");
-  return createHash("sha256").update(normalized, "utf8").digest("hex");
-}
-function classifyPublishMode(ast) {
-  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
-  const hasImports = Array.isArray(imports) && imports.length > 0;
-  if (!hasImports) return "original";
-  const body = ast?.body ?? ast?.ast?.body ?? [];
-  const hasOwnContent = Array.isArray(body) && body.some(
-    (node) => node.type === "composition" || node.type === "ObjectDeclaration" || node.type === "scene" || node.type === "object" || node.type === "character" || node.type === "environment"
-  );
-  if (hasOwnContent) return "remix";
-  return "curated";
-}
-function extractImports(ast) {
-  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
-  if (!Array.isArray(imports)) return [];
-  return imports.map((imp) => ({
-    // @ts-expect-error
-    path: imp.path ?? imp.source ?? "",
-    // @ts-expect-error
-    hash: imp.hash,
-    // @ts-expect-error
-    author: imp.author
-  })).filter((imp) => imp.path.length > 0);
-}
-function generateProvenance(source, ast, options) {
-  return {
-    author: options.author,
-    created: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    hash: computeContentHash(source),
-    license: options.license,
-    version: 1,
-    publishMode: classifyPublishMode(ast),
-    imports: extractImports(ast)
-  };
-}
 
 // src/deploy/license-checker.ts
 var RESTRICTIVENESS = {
@@ -970,6 +1238,6 @@ function weiToEth(wei) {
   return `${whole}.${fraction}`;
 }
 
-export { CompositionTestRunner, DEFAULT_STDLIB_POLICY, PROTOCOL_CONSTANTS, TEST_TRAIT, calculateRevenueDistribution, checkLicenseCompatibility, classifyPublishMode, computeContentHash, createStdlibActions, ethToWei, extractImports, formatRevenueDistribution, generateProvenance, isPathAllowed, parseHostFromUrl, registerStdlib, resolveImportChain, resolveRepoRelativePath, testHandler, toStringArray, truncateText, weiToEth };
-//# sourceMappingURL=chunk-DMG7C4H2.js.map
-//# sourceMappingURL=chunk-DMG7C4H2.js.map
+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