@holoscript/core 6.0.3 → 6.1.1

package/dist/{chunk-GC3YU46J.js → chunk-2M2DPHKB.js}

@@ -229,7 +229,7 @@ var AbsorbProcessor = class {
       for (const method of cls.methods) {
         const params = method.params.map((p) => p.name).join(", ");
         lines.push(`  on ${method.name}(${params}) {`);
-        lines.push(`    // TODO: port ${method.name} logic`);
+        lines.push(`    // ABSORB-STUB: port ${method.name} logic`);
         lines.push(`  }`);
       }
       lines.push(`}`);
@@ -242,7 +242,7 @@ var AbsorbProcessor = class {
       lines.push(
         `${asyncPrefix}fn ${fn.name}(${params})${fn.returnType ? ` -> ${fn.returnType}` : ""} {`
       );
-      lines.push(`  // TODO: port ${fn.name} logic from ${result.sourceLanguage}`);
+      lines.push(`  // ABSORB-STUB: port ${fn.name} logic from ${result.sourceLanguage}`);
       lines.push(`}`);
       lines.push("");
     }
@@ -758,5 +758,5 @@ var scriptTestHandler = {
 };
 
 export { ABSORB_TRAIT, AbsorbProcessor, HOT_RELOAD_TRAIT, HotReloadWatcher, SCRIPT_TEST_TRAIT, ScriptTestRunner, absorbHandler, hotReloadHandler, scriptTestHandler };
-//# sourceMappingURL=chunk-GC3YU46J.js.map
-//# sourceMappingURL=chunk-GC3YU46J.js.map
+//# sourceMappingURL=chunk-2M2DPHKB.js.map
+//# sourceMappingURL=chunk-2M2DPHKB.js.map

package/dist/{chunk-A6GO3DPZ.cjs → chunk-2YSNA2F2.cjs}

@@ -1,13 +1,12 @@
 'use strict';
 
+var chunkE7JP3BS3_cjs = require('./chunk-E7JP3BS3.cjs');
 var path = require('path');
-var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path__default = /*#__PURE__*/_interopDefault(path);
 
-// src/stdlib/StdlibActions.ts
 var DEFAULT_STDLIB_POLICY = {
   allowedPaths: ["compositions", "data", "src", "packages"],
   maxFileBytes: 2 * 1024 * 1024,
@@ -21,6 +20,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
@@ -209,6 +217,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() : "";
@@ -276,7 +460,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
+chunkE7JP3BS3_cjs.init_safeJsonParse();
 var CompositionTestRunner = class {
   constructor(initialState, computedDefs = [], config = {}) {
     this.initialState = { ...initialState };
@@ -293,7 +599,7 @@ var CompositionTestRunner = class {
   runTestsFromSource(source) {
     const tests = this.extractTestBlocks(source);
     if (this.config.debug) {
-      console.log(`[composition_test] Found ${tests.length} @test blocks`);
+      console.debug(`[composition_test] Found ${tests.length} @test blocks`);
     }
     return this.runAll(tests);
   }
@@ -340,7 +646,7 @@ var CompositionTestRunner = class {
       const computed = this.evaluateComputedValues(state);
       const fullState = { ...state, ...computed };
       if (this.config.debug) {
-        console.log(`[composition_test] "${test.name}" state:`, fullState);
+        console.debug(`[composition_test] "${test.name}" state:`, fullState);
       }
       for (const assertion of test.assertions) {
         const passed = this.evaluateAssertion(assertion.expression, fullState);
@@ -618,7 +924,7 @@ function parseNestedBlock(body) {
       }
       const arrStr = body.substring(arrStart, i).trim();
       try {
-        result[key] = JSON.parse(arrStr);
+        result[key] = chunkE7JP3BS3_cjs.readJson(arrStr);
       } catch {
         result[key] = arrStr;
       }
@@ -689,44 +995,6 @@ var testHandler = {
     }
   }
 };
-function computeContentHash(source) {
-  const normalized = source.replace(/\r\n/g, "\n");
-  return crypto.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 = {
@@ -980,23 +1248,27 @@ exports.CompositionTestRunner = CompositionTestRunner;
 exports.DEFAULT_STDLIB_POLICY = DEFAULT_STDLIB_POLICY;
 exports.PROTOCOL_CONSTANTS = PROTOCOL_CONSTANTS;
 exports.TEST_TRAIT = TEST_TRAIT;
+exports.buildStdlibPermissionScopeDiff = buildStdlibPermissionScopeDiff;
 exports.calculateRevenueDistribution = calculateRevenueDistribution;
 exports.checkLicenseCompatibility = checkLicenseCompatibility;
-exports.classifyPublishMode = classifyPublishMode;
-exports.computeContentHash = computeContentHash;
 exports.createStdlibActions = createStdlibActions;
 exports.ethToWei = ethToWei;
-exports.extractImports = extractImports;
+exports.evaluateStdlibPermissionScopePolicy = evaluateStdlibPermissionScopePolicy;
+exports.findExtraPermissionScopes = findExtraPermissionScopes;
+exports.findMissingRequiredPermissionScopes = findMissingRequiredPermissionScopes;
 exports.formatRevenueDistribution = formatRevenueDistribution;
-exports.generateProvenance = generateProvenance;
 exports.isPathAllowed = isPathAllowed;
+exports.isValidPermissionScopeName = isValidPermissionScopeName;
+exports.normalizePermissionScopeName = normalizePermissionScopeName;
 exports.parseHostFromUrl = parseHostFromUrl;
+exports.redactStdlibPermissionPreview = redactStdlibPermissionPreview;
 exports.registerStdlib = registerStdlib;
 exports.resolveImportChain = resolveImportChain;
 exports.resolveRepoRelativePath = resolveRepoRelativePath;
+exports.stdlibPermissionPreviewHasPublicLeak = stdlibPermissionPreviewHasPublicLeak;
 exports.testHandler = testHandler;
 exports.toStringArray = toStringArray;
 exports.truncateText = truncateText;
 exports.weiToEth = weiToEth;
-//# sourceMappingURL=chunk-A6GO3DPZ.cjs.map
-//# sourceMappingURL=chunk-A6GO3DPZ.cjs.map
+//# sourceMappingURL=chunk-2YSNA2F2.cjs.map
+//# sourceMappingURL=chunk-2YSNA2F2.cjs.map

package/dist/{chunk-ZL6VJ6SN.js → chunk-33XCOVE3.js}

@@ -1,5 +1,6 @@
-import { init_CompilerBase, init_ANSNamespace, CompilerBase, ANSCapabilityPath } from './chunk-QWKUKVRE.js';
-import { __export, __esm } from './chunk-32TWR3HE.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QTPMJRGS.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/DTDLCompiler.ts
 var DTDLCompiler_exports = {};
@@ -12,7 +13,6 @@ var DTDLCompiler, DTDL_TRAIT_COMPONENTS, DTDLCompiler_default;
 var init_DTDLCompiler = __esm({
   "src/compiler/DTDLCompiler.ts"() {
     init_CompilerBase();
-    init_ANSNamespace();
     DTDLCompiler = class extends CompilerBase {
       constructor(options = {}) {
         super();
@@ -417,5 +417,5 @@ var init_DTDLCompiler = __esm({
 });
 
 export { DTDLCompiler, DTDLCompiler_default, DTDLCompiler_exports, DTDL_TRAIT_COMPONENTS, init_DTDLCompiler };
-//# sourceMappingURL=chunk-ZL6VJ6SN.js.map
-//# sourceMappingURL=chunk-ZL6VJ6SN.js.map
+//# sourceMappingURL=chunk-33XCOVE3.js.map
+//# sourceMappingURL=chunk-33XCOVE3.js.map