@faicad/faijs 0.13.2 → 0.16.0

package/dist/vendored/brepjs/core/kernelReentrancy.d.ts

@@ -1,41 +0,0 @@
-/**
- * Kernel reentrancy guard.
- *
- * occt-wasm's arena `release()` is not reentrant-safe with respect to an
- * in-progress wasm/embind call on the same JS stack: a `FinalizationRegistry`
- * finalizer firing at an arbitrary GC point (e.g. at a JS allocation *inside*
- * an executing kernel method) must not synchronously call `kernel.dispose()`
- * — doing so re-enters the native runtime mid-call and can deadlock the event
- * loop (p23-cad-face root cause; see the disposal analysis doc).
- *
- * Every kernel adapter method call is wrapped to increment/decrement a depth
- * counter, so a finalizer can ask "am I still on the kernel's stack?" and, if
- * so, defer its disposal until the outermost kernel call has fully unwound.
- *
- * The flush path is synchronous and runs *after* the kernel call that was on
- * the stack has returned, which is exactly the safe window: no wasm frame is
- * live, and the disposal call that immediately follows re-enters through the
- * guard cleanly (depth 0 → 1 → 0) instead of racing a native caller.
- *
- * Live-handle accounting and the arena `< 100` bound are preserved: when the
- * kernel is idle the deferred closure is invoked synchronously (same behavior
- * as today), so the common GC-with-no-kernel-call case costs nothing.
- */
-/** Number of kernel calls currently on the JS stack (0 = kernel idle). */
-export declare function kernelReentrancyDepth(): number;
-/** Enter a kernel call. Must be paired with a later {@link leaveKernelCall}. */
-export declare function enterKernelCall(): void;
-/**
- * Leave a kernel call and, when the outermost call unwound, drain deferred
- * work. Safe to over-call (depth is clamped at zero) so a defensive guard can
- * `leave` a call that never `enter`ed.
- */
-export declare function leaveKernelCall(): void;
-/**
- * Run `fn` when the kernel is fully idle (no call on the stack). If a call is
- * in flight, defer to the point its outermost call unwinds.
- *
- * Used by GC finalizers to push disposal out of the reentrant window.
- */
-export declare function runWhenKernelIdle(fn: () => void): void;
-//# sourceMappingURL=kernelReentrancy.d.ts.map

package/dist/vendored/brepjs/core/kernelReentrancy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kernelReentrancy.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelReentrancy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,0EAA0E;AAC1E,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,gFAAgF;AAChF,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAatC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAMtD"}

package/dist/vendored/brepjs/core/kernelReentrancy.js

@@ -1,68 +0,0 @@
-/**
- * Kernel reentrancy guard.
- *
- * occt-wasm's arena `release()` is not reentrant-safe with respect to an
- * in-progress wasm/embind call on the same JS stack: a `FinalizationRegistry`
- * finalizer firing at an arbitrary GC point (e.g. at a JS allocation *inside*
- * an executing kernel method) must not synchronously call `kernel.dispose()`
- * — doing so re-enters the native runtime mid-call and can deadlock the event
- * loop (p23-cad-face root cause; see the disposal analysis doc).
- *
- * Every kernel adapter method call is wrapped to increment/decrement a depth
- * counter, so a finalizer can ask "am I still on the kernel's stack?" and, if
- * so, defer its disposal until the outermost kernel call has fully unwound.
- *
- * The flush path is synchronous and runs *after* the kernel call that was on
- * the stack has returned, which is exactly the safe window: no wasm frame is
- * live, and the disposal call that immediately follows re-enters through the
- * guard cleanly (depth 0 → 1 → 0) instead of racing a native caller.
- *
- * Live-handle accounting and the arena `< 100` bound are preserved: when the
- * kernel is idle the deferred closure is invoked synchronously (same behavior
- * as today), so the common GC-with-no-kernel-call case costs nothing.
- */
-let depth = 0;
-let drainHooks = [];
-/** Number of kernel calls currently on the JS stack (0 = kernel idle). */
-export function kernelReentrancyDepth() {
-    return depth;
-}
-/** Enter a kernel call. Must be paired with a later {@link leaveKernelCall}. */
-export function enterKernelCall() {
-    depth++;
-}
-/**
- * Leave a kernel call and, when the outermost call unwound, drain deferred
- * work. Safe to over-call (depth is clamped at zero) so a defensive guard can
- * `leave` a call that never `enter`ed.
- */
-export function leaveKernelCall() {
-    if (depth > 0)
-        depth--;
-    if (depth === 0) {
-        const hooks = drainHooks;
-        drainHooks = [];
-        for (const hook of hooks) {
-            try {
-                hook();
-            }
-            catch {
-                // A deferred disposal must never break the unwinding kernel call.
-            }
-        }
-    }
-}
-/**
- * Run `fn` when the kernel is fully idle (no call on the stack). If a call is
- * in flight, defer to the point its outermost call unwinds.
- *
- * Used by GC finalizers to push disposal out of the reentrant window.
- */
-export function runWhenKernelIdle(fn) {
-    if (depth === 0) {
-        fn();
-        return;
-    }
-    drainHooks.push(fn);
-}
-//# sourceMappingURL=kernelReentrancy.js.map

package/dist/vendored/brepjs/core/kernelReentrancy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kernelReentrancy.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelReentrancy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,IAAI,KAAK,GAAG,CAAC,CAAC;AACd,IAAI,UAAU,GAAsB,EAAE,CAAC;AAEvC,0EAA0E;AAC1E,MAAM,UAAU,qBAAqB;IACnC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,eAAe;IAC7B,KAAK,EAAE,CAAC;AACV,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe;IAC7B,IAAI,KAAK,GAAG,CAAC;QAAE,KAAK,EAAE,CAAC;IACvB,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,MAAM,KAAK,GAAG,UAAU,CAAC;QACzB,UAAU,GAAG,EAAE,CAAC;QAChB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,IAAI,EAAE,CAAC;YACT,CAAC;YAAC,MAAM,CAAC;gBACP,kEAAkE;YACpE,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAAc;IAC9C,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,EAAE,EAAE,CAAC;QACL,OAAO;IACT,CAAC;IACD,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACtB,CAAC","sourcesContent":["/**\n * Kernel reentrancy guard.\n *\n * occt-wasm's arena `release()` is not reentrant-safe with respect to an\n * in-progress wasm/embind call on the same JS stack: a `FinalizationRegistry`\n * finalizer firing at an arbitrary GC point (e.g. at a JS allocation *inside*\n * an executing kernel method) must not synchronously call `kernel.dispose()`\n * — doing so re-enters the native runtime mid-call and can deadlock the event\n * loop (p23-cad-face root cause; see the disposal analysis doc).\n *\n * Every kernel adapter method call is wrapped to increment/decrement a depth\n * counter, so a finalizer can ask \"am I still on the kernel's stack?\" and, if\n * so, defer its disposal until the outermost kernel call has fully unwound.\n *\n * The flush path is synchronous and runs *after* the kernel call that was on\n * the stack has returned, which is exactly the safe window: no wasm frame is\n * live, and the disposal call that immediately follows re-enters through the\n * guard cleanly (depth 0 → 1 → 0) instead of racing a native caller.\n *\n * Live-handle accounting and the arena `< 100` bound are preserved: when the\n * kernel is idle the deferred closure is invoked synchronously (same behavior\n * as today), so the common GC-with-no-kernel-call case costs nothing.\n */\n\nlet depth = 0;\nlet drainHooks: Array<() => void> = [];\n\n/** Number of kernel calls currently on the JS stack (0 = kernel idle). */\nexport function kernelReentrancyDepth(): number {\n  return depth;\n}\n\n/** Enter a kernel call. Must be paired with a later {@link leaveKernelCall}. */\nexport function enterKernelCall(): void {\n  depth++;\n}\n\n/**\n * Leave a kernel call and, when the outermost call unwound, drain deferred\n * work. Safe to over-call (depth is clamped at zero) so a defensive guard can\n * `leave` a call that never `enter`ed.\n */\nexport function leaveKernelCall(): void {\n  if (depth > 0) depth--;\n  if (depth === 0) {\n    const hooks = drainHooks;\n    drainHooks = [];\n    for (const hook of hooks) {\n      try {\n        hook();\n      } catch {\n        // A deferred disposal must never break the unwinding kernel call.\n      }\n    }\n  }\n}\n\n/**\n * Run `fn` when the kernel is fully idle (no call on the stack). If a call is\n * in flight, defer to the point its outermost call unwinds.\n *\n * Used by GC finalizers to push disposal out of the reentrant window.\n */\nexport function runWhenKernelIdle(fn: () => void): void {\n  if (depth === 0) {\n    fn();\n    return;\n  }\n  drainHooks.push(fn);\n}"]}