@code3d/core 0.0.1-alpha.6 → 0.0.1-alpha.7

package/README.md

@@ -194,10 +194,19 @@ Try [mounting-plate.ts](../app/examples/sketches/mounting-plate.ts).
 
 ## Cached computations and custom primitives
 
-`cached(fn, options?)` memoizes synchronous, deterministic data computations.
+`cache(fn)` memoizes synchronous, deterministic data computations;
+`cache(fn, args)` immediately returns the cached result for an argument tuple.
+Both forms share the same function identity and argument keys. Supply custom
+codecs in the third argument: `cache(fn, undefined, options)` for a function or
+`cache(fn, args, options)` for a value.
 Pass changing captured state as arguments and treat returned data as immutable.
 Memory hits reuse the retained result; optional `encoder` / `decoder` pairs only
-run when saving to disk or restoring it. The App fingerprints static definitions
+run when saving to disk or restoring it. Newly computed entries are eligible
+for disk storage when computation reaches the configured threshold (1 ms by
+default). Faster results remain in memory and are not encoded or written on later
+memory hits. Change the threshold in **Settings → Cache** in the App; it applies
+to new computations and preserves existing cache entries. Existing
+disk records can still be restored. The App fingerprints static definitions
 and their dependencies for persistent reuse; dynamic closures and ordinary Node
 calls use function identity for memory reuse. No author cache IDs are needed.
 

package/bld/chunks/{chunk-T3RAUNSF.js → chunk-4WLVDYUJ.js}

@@ -369,6 +369,7 @@ __name(estimateRetainedBytes, "estimateRetainedBytes");
 // packages/core/src/library/kernel-cache.ts
 function createComputationCache({
   maximumBytes = 2 * 1024 ** 3,
+  minimumPersistenceMilliseconds = 1,
   nativeAllocatedBytes
 }) {
   const entries = /* @__PURE__ */ new Map();
@@ -391,6 +392,10 @@ function createComputationCache({
     evictHistoricalEntries();
   }
   __name(setKernelCacheBudget2, "setKernelCacheBudget");
+  function setKernelCachePersistenceThreshold2(milliseconds) {
+    minimumPersistenceMilliseconds = milliseconds;
+  }
+  __name(setKernelCachePersistenceThreshold2, "setKernelCachePersistenceThreshold");
   function setKernelExternalBytes2(bytes) {
     externalBytes = bytes;
     evictHistoricalEntries();
@@ -431,8 +436,10 @@ function createComputationCache({
   function evaluateCachedArtifact2(key, lifecycle, compute, codec) {
     const hit = findKernelOperation2(key, lifecycle, codec);
     if (hit) return hit;
+    const started = performance.now();
     const value = compute();
-    acceptKernelOperation2(key, lifecycle, value, codec);
+    const milliseconds = performance.now() - started;
+    acceptKernelOperation2(key, lifecycle, value, milliseconds, codec);
     return { id: key.id, value };
   }
   __name(evaluateCachedArtifact2, "evaluateCachedArtifact");
@@ -460,8 +467,8 @@ function createComputationCache({
   function lookup(key, lifecycle, codec, read) {
     currentEvaluation?.checkCancelled?.();
     const { id, signature } = key;
-    let cached2 = entries.get(id);
-    if (!cached2 && codec !== false) {
+    let cached = entries.get(id);
+    if (!cached && codec !== false) {
       const bytes = read();
       if (bytes) {
         let restored;
@@ -473,25 +480,26 @@ function createComputationCache({
           misses += 1;
           return void 0;
         }
-        cached2 = retainEntry(key, lifecycle, restored);
+        cached = retainEntry(key, lifecycle, restored, true);
         persistentHits += 1;
         persisted.add(id);
       }
     }
-    if (!cached2) {
+    if (!cached) {
       misses += 1;
       return void 0;
     }
-    if (cached2.signature !== signature)
+    if (cached.signature !== signature)
       throw new Error(`Kernel operation cache identity collision: ${id}`);
     hits += 1;
-    const value = cached2.instantiate(cached2.value);
-    if (codec !== false) persist(key, cached2.value, codec, true);
-    touchEntry(id, cached2);
+    const value = cached.instantiate(cached.value);
+    if (cached.persistenceEligible && codec !== false)
+      persist(key, cached.value, codec, true);
+    touchEntry(id, cached);
     return { id, value };
   }
   __name(lookup, "lookup");
-  function acceptKernelOperation2(key, lifecycle, value, codec) {
+  function acceptKernelOperation2(key, lifecycle, value, milliseconds, codec) {
     const existing = entries.get(key.id);
     if (existing) {
       if (existing.signature !== key.signature)
@@ -506,8 +514,14 @@ function createComputationCache({
       lifecycle.release(value);
       throw error;
     }
-    const entry = retainEntry(key, lifecycle, retained);
-    if (codec !== false) persist(key, retained, codec);
+    const entry = retainEntry(
+      key,
+      lifecycle,
+      retained,
+      milliseconds >= minimumPersistenceMilliseconds
+    );
+    if (entry.persistenceEligible && codec !== false)
+      persist(key, retained, codec);
     touchEntry(key.id, entry);
   }
   __name(acceptKernelOperation2, "acceptKernelOperation");
@@ -553,8 +567,9 @@ function createComputationCache({
     pendingPersistence.clear();
   }
   __name(flushPendingPersistence, "flushPendingPersistence");
-  function retainEntry(key, lifecycle, retained) {
+  function retainEntry(key, lifecycle, retained, persistenceEligible) {
     const entry = {
+      persistenceEligible,
       estimatedBytes: 256 + estimateRetainedBytes(key.signature) + lifecycle.estimateBytes(retained),
       signature: key.signature,
       value: retained,
@@ -630,6 +645,7 @@ function createComputationCache({
     clearKernelOperationCache: clearKernelOperationCache2,
     kernelOperationCacheStats: kernelOperationCacheStats2,
     setKernelCacheBudget: setKernelCacheBudget2,
+    setKernelCachePersistenceThreshold: setKernelCachePersistenceThreshold2,
     setKernelArtifactStore: setKernelArtifactStore2,
     findKernelOperation: findKernelOperation2,
     findKernelOperations: findKernelOperations2,
@@ -649,6 +665,7 @@ var {
   clearKernelOperationCache,
   kernelOperationCacheStats,
   setKernelCacheBudget,
+  setKernelCachePersistenceThreshold,
   setKernelArtifactStore,
   findKernelOperation,
   findKernelOperations,
@@ -713,19 +730,19 @@ var dataLifecycle = {
   release() {
   }
 };
-function cached(compute, options) {
+function cache(compute, args, options) {
   const operation = cachedArtifact(
-    (...args) => {
-      const value = compute(...args);
+    (...args2) => {
+      const value = compute(...args2);
       if (value && typeof value === "object" && "then" in value && typeof value.then === "function")
-        throw new Error("cached() requires a synchronous computation.");
+        throw new Error("cache() requires a synchronous computation.");
       return value;
     },
     { identity: compute, codec: options }
   );
-  return (...args) => operation(...args).value;
+  return args === void 0 ? (...args2) => operation(...args2).value : operation(...args).value;
 }
-__name(cached, "cached");
+__name(cache, "cache");
 function cachedArtifact(compute, {
   key,
   lifecycle = dataLifecycle,
@@ -742,7 +759,7 @@ function cachedArtifact(compute, {
   ));
   const find = /* @__PURE__ */ __name((key2) => findKernelOperation(key2, lifecycle, persistence), "find");
   const findMany = /* @__PURE__ */ __name((keys) => findKernelOperations(keys, lifecycle, persistence), "findMany");
-  const accept = /* @__PURE__ */ __name((key2, value) => acceptKernelOperation(key2, lifecycle, value, persistence), "accept");
+  const accept = /* @__PURE__ */ __name((key2, value, milliseconds) => acceptKernelOperation(key2, lifecycle, value, milliseconds, persistence), "accept");
   return Object.assign(
     (...args) => {
       return evaluateCachedArtifact(
@@ -23375,7 +23392,7 @@ function planModelSnapshotQueries(objects) {
     sourceRef,
     weight: (1 + (input.geometry.topology?.edges.ids.length ?? 0) + (input.geometry.topology?.surfaces.ids.length ?? 0)) * queries.length,
     encode: /* @__PURE__ */ __name(() => encodeKernelArtifact(id, input.geometry), "encode"),
-    accept: /* @__PURE__ */ __name((query, value) => snapshotQuery.accept(query.key, value), "accept")
+    accept: /* @__PURE__ */ __name((query, value, milliseconds) => snapshotQuery.accept(query.key, value, milliseconds), "accept")
   }));
 }
 __name(planModelSnapshotQueries, "planModelSnapshotQueries");
@@ -23389,7 +23406,9 @@ function executeSnapshotQueryBatch(id, bytes, queries, checkCancelled, onResult,
     onRestore?.(performance.now() - started);
     for (const query of queries) {
       checkCancelled();
-      onResult(query, computeSnapshotQuery(geometry, query));
+      const started2 = performance.now();
+      const value = computeSnapshotQuery(geometry, query);
+      onResult(query, value, performance.now() - started2);
     }
   } finally {
     geometry.shape.delete();
@@ -23457,7 +23476,7 @@ var authoringApi = Object.freeze({
   pivotPoint,
   axisEdge,
   axisLine,
-  cached,
+  cache,
   font,
   googleFont,
   text,
@@ -23585,15 +23604,15 @@ function evaluateSolidGeometry(operation, arguments_, inputs, compute) {
   );
 }
 __name(evaluateSolidGeometry, "evaluateSolidGeometry");
-function renderMesh(artifact, shape, cache, tolerance2, topology) {
-  const cached2 = cache.get(shape);
-  if (cached2) {
-    return cached2;
+function renderMesh(artifact, shape, cache2, tolerance2, topology) {
+  const cached = cache2.get(shape);
+  if (cached) {
+    return cached;
   }
   const mesh = evaluateSnapshotQuery(
     meshQuery(artifact, shape, tolerance2, topology)
   );
-  cache.set(shape, mesh);
+  cache2.set(shape, mesh);
   return mesh;
 }
 __name(renderMesh, "renderMesh");
@@ -24655,8 +24674,8 @@ function sketchPointResolver(layers) {
   const visiting = /* @__PURE__ */ new Set();
   const resolve = /* @__PURE__ */ __name((ref) => {
     const key = JSON.stringify([ref.layer, ref.id]);
-    const cached2 = resolved.get(key);
-    if (cached2) return cached2;
+    const cached = resolved.get(key);
+    if (cached) return cached;
     const point3 = points.get(key);
     if (!point3) throw new Error(`Missing sketch point ${ref.id}.`);
     if (visiting.has(key))
@@ -25161,10 +25180,11 @@ export {
   clearKernelOperationCache,
   kernelOperationCacheStats,
   setKernelCacheBudget,
+  setKernelCachePersistenceThreshold,
   setKernelArtifactStore,
   setKernelExternalBytes,
   identifyCachedFunction,
-  cached,
+  cache,
   googleFontUrl,
   googleFontSources,
   installFontEngine,
@@ -25266,4 +25286,4 @@ export {
   assertSketchDragConnections,
   solveSketchSnapshot
 };
-//# sourceMappingURL=chunk-T3RAUNSF.js.map
+//# sourceMappingURL=chunk-4WLVDYUJ.js.map