@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-L6B6FUQP.js

@@ -0,0 +1,330 @@
+// packages/contracts/src/bundle.ts
+function bundleFieldType(definition) {
+  if (!definition) return "any";
+  return typeof definition === "string" ? definition : definition.type;
+}
+function bundleSchemasCompatible(output, input) {
+  return !output || !input || output === input;
+}
+function isBundleValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function selectBundleFields(value, fields) {
+  if (!isBundleValue(value)) return value;
+  const selected = {};
+  for (const field of fields)
+    if (Object.prototype.hasOwnProperty.call(value, field)) selected[field] = value[field];
+  return Object.freeze(selected);
+}
+function suggestName(name, candidates) {
+  let best;
+  let bestDistance = Infinity;
+  const lower = name.toLowerCase();
+  for (const candidate of candidates) {
+    const distance = editDistance(lower, candidate.toLowerCase());
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  if (best === void 0) return void 0;
+  const limit = Math.max(1, Math.floor(Math.max(name.length, best.length) / 3));
+  return bestDistance <= limit ? best : void 0;
+}
+function unknownFieldMessage(field, known, where) {
+  const suggestion = suggestName(field, known);
+  return `${where} reads unknown bundle field "${field}"` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : "") + (known.length ? ` (fields: ${known.join(", ")})` : " (the bundle declares no fields)");
+}
+function bundleValueProblem(value, fields) {
+  if (value === void 0 || value === null) return null;
+  if (!isBundleValue(value)) return "a bundle must be a plain object of fields";
+  if (!fields) return null;
+  const known = Object.keys(fields);
+  for (const key of Object.keys(value))
+    if (!Object.prototype.hasOwnProperty.call(fields, key)) {
+      const suggestion = suggestName(key, known);
+      return `sets undeclared bundle field "${key}"` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : "") + ` (declared: ${known.join(", ") || "none"})`;
+    }
+  return null;
+}
+function editDistance(a, b) {
+  const previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = previous[j];
+      previous[j] = Math.min(
+        previous[j] + 1,
+        previous[j - 1] + 1,
+        diagonal + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+      diagonal = above;
+    }
+  }
+  return previous[b.length];
+}
+
+// packages/runtime/src/gpu.ts
+var HOST_SCOPE = "\0host";
+var MISSING_DEVICE = "The gpu capability was used before its device was ready \u2014 the host must await ensure() before a cook.";
+var DISPOSED = "The gpu capability has been disposed.";
+function isGpuHost(value) {
+  return !!value && typeof value.ensure === "function" && typeof value.forNode === "function" && typeof value.dispose === "function";
+}
+function createGpuHost(options) {
+  let active = null;
+  let starting = null;
+  let disposal = null;
+  let disposed = false;
+  const caches = /* @__PURE__ */ new Map();
+  const retiring = /* @__PURE__ */ new Set();
+  const retirementErrors = [];
+  function dropCaches() {
+    const errors = [];
+    const scopes = [...caches.values()];
+    caches.clear();
+    for (const entries of scopes) {
+      for (const entry of entries.values()) {
+        try {
+          entry.destroy?.(entry.value);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+    }
+    return errors;
+  }
+  async function release(acquired, destroyDevice) {
+    if (acquired.released) return [];
+    acquired.released = true;
+    const errors = [];
+    if (destroyDevice) {
+      try {
+        acquired.device.destroy();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    try {
+      await acquired.release?.();
+    } catch (error) {
+      errors.push(error);
+    }
+    return errors;
+  }
+  function throwCleanupErrors(errors) {
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) {
+      const combined = new Error("GPU host cleanup failed");
+      Object.assign(combined, { errors });
+      throw combined;
+    }
+  }
+  function watchLoss(acquired) {
+    void acquired.device.lost.then(() => {
+      if (disposed || active !== acquired) return;
+      active = null;
+      retirementErrors.push(...dropCaches());
+      const cleanup = release(acquired, false).then((errors) => {
+        retirementErrors.push(...errors);
+      });
+      retiring.add(cleanup);
+      void cleanup.finally(() => retiring.delete(cleanup));
+    }).catch(() => {
+    });
+  }
+  async function start() {
+    const result = await options.acquire();
+    const acquired = {
+      device: result.device,
+      info: {
+        vendor: result.info?.vendor ?? "",
+        architecture: result.info?.architecture ?? "",
+        device: result.info?.device ?? "",
+        description: result.info?.description ?? ""
+      },
+      limits: readGpuLimits(result.limits),
+      release: result.release,
+      released: false
+    };
+    if (disposed) {
+      const errors = await release(acquired, true);
+      throwCleanupErrors(errors);
+      throw new Error(DISPOSED);
+    }
+    active = acquired;
+    watchLoss(acquired);
+  }
+  const host = {
+    get device() {
+      if (!active) throw new Error(MISSING_DEVICE);
+      return active.device;
+    },
+    get adapterInfo() {
+      if (!active) throw new Error(MISSING_DEVICE);
+      return active.info;
+    },
+    get limits() {
+      return active?.limits ?? {};
+    },
+    cache(key, create, destroy) {
+      return host.forNode(HOST_SCOPE).cache(key, create, destroy);
+    },
+    async ensure() {
+      if (disposed) throw new Error(DISPOSED);
+      if (active) return;
+      if (!starting) {
+        const attempt = start();
+        const tracked = attempt.finally(() => {
+          if (starting === tracked) starting = null;
+        });
+        starting = tracked;
+      }
+      await starting;
+    },
+    forNode(nodeId) {
+      return {
+        get device() {
+          if (!active) throw new Error(MISSING_DEVICE);
+          return active.device;
+        },
+        get adapterInfo() {
+          if (!active) throw new Error(MISSING_DEVICE);
+          return active.info;
+        },
+        get limits() {
+          return active?.limits ?? {};
+        },
+        cache(key, create, destroy) {
+          if (!active) throw new Error(MISSING_DEVICE);
+          let entries = caches.get(nodeId);
+          if (!entries) {
+            entries = /* @__PURE__ */ new Map();
+            caches.set(nodeId, entries);
+          }
+          const existing = entries.get(key);
+          if (existing) return existing.value;
+          const value = create(active.device);
+          entries.set(key, {
+            value,
+            destroy
+          });
+          return value;
+        }
+      };
+    },
+    dispose() {
+      disposal ??= performDispose();
+      return disposal;
+    }
+  };
+  async function performDispose() {
+    disposed = true;
+    const errors = dropCaches();
+    const pending = starting;
+    if (pending) {
+      try {
+        await pending;
+      } catch (error) {
+        if (!(error instanceof Error && error.message === DISPOSED))
+          errors.push(error);
+      }
+    }
+    const acquired = active;
+    active = null;
+    if (acquired) errors.push(...await release(acquired, true));
+    await Promise.all([...retiring]);
+    errors.push(...retirementErrors);
+    retirementErrors.length = 0;
+    throwCleanupErrors(errors);
+  }
+  return host;
+}
+async function requestDeviceWithAdapterLimits(adapter) {
+  const requiredLimits = readGpuLimits(adapter.limits);
+  try {
+    return await adapter.requestDevice({ requiredLimits });
+  } catch {
+    return adapter.requestDevice();
+  }
+}
+function gpuLimitShortfall(label, required, gpu) {
+  if (!required) return null;
+  const short = [];
+  for (const [name, wanted] of Object.entries(required)) {
+    const have = gpu.limits[name];
+    const fits = have !== void 0 && (name.startsWith("min") ? have <= wanted : have >= wanted);
+    if (!fits) short.push(`${name} ${wanted} (this GPU: ${have ?? "not reported"})`);
+  }
+  if (!short.length) return null;
+  const adapter = gpu.adapterInfo.description || gpu.adapterInfo.device || gpu.adapterInfo.vendor || "this adapter";
+  return `${label} needs GPU limits ${adapter} does not allow: ${short.join(", ")}.`;
+}
+function readGpuLimits(source) {
+  if (!source || typeof source !== "object") return {};
+  const names = new Set(Object.keys(source));
+  for (let cursor = Object.getPrototypeOf(source); cursor && cursor !== Object.prototype; cursor = Object.getPrototypeOf(cursor)) {
+    for (const key of Object.getOwnPropertyNames(cursor)) {
+      if (key !== "constructor") names.add(key);
+    }
+  }
+  const limits = {};
+  for (const key of names) {
+    const value = source[key];
+    if (typeof value === "number") limits[key] = value;
+  }
+  return limits;
+}
+
+// packages/runtime/src/seed.ts
+var DEFAULT_GRAPH_SEED = 0;
+function graphSeed(document) {
+  const value = document?.seed;
+  return typeof value === "number" && Number.isInteger(value) ? value >>> 0 : DEFAULT_GRAPH_SEED;
+}
+function nodeSeed(seedOfGraph, nodeId) {
+  const text = `${seedOfGraph >>> 0}:${nodeId}`;
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index++) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507);
+  hash ^= hash >>> 13;
+  hash = Math.imul(hash, 3266489909);
+  hash ^= hash >>> 16;
+  return hash >>> 0;
+}
+function seededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+export {
+  bundleFieldType,
+  bundleSchemasCompatible,
+  isBundleValue,
+  selectBundleFields,
+  suggestName,
+  unknownFieldMessage,
+  bundleValueProblem,
+  isGpuHost,
+  createGpuHost,
+  requestDeviceWithAdapterLimits,
+  gpuLimitShortfall,
+  DEFAULT_GRAPH_SEED,
+  graphSeed,
+  nodeSeed,
+  seededRandom
+};
+//# sourceMappingURL=chunk-L6B6FUQP.js.map