@faicad/faijs 0.13.0

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

@@ -0,0 +1,48 @@
+/**
+ * Error handling helpers for kernel operations.
+ *
+ * Reduces boilerplate in *Fns.ts files by wrapping try/catch + castShape
+ * into a single call.
+ */
+import type { KernelShape } from '../kernel/types.js';
+import type { AnyShape } from './shapeTypes.js';
+import type { Result } from './result.js';
+import type { BrepErrorKind } from './errors.js';
+import { DisposalScope } from './disposal.js';
+/**
+ * Wrap a kernel call that returns an KernelShape, automatically casting
+ * the result into a branded AnyShape. On exception, returns an Err
+ * with the given error code and message.
+ *
+ * kernel error messages are automatically translated into user-friendly
+ * explanations when the error kind is KERNEL_OPERATION.
+ */
+export declare function kernelCall(fn: () => KernelShape, code: string, message: string, kind?: BrepErrorKind): Result<AnyShape>;
+/**
+ * Wrap a kernel call that returns an arbitrary value. On exception,
+ * returns an Err with the given error code and message.
+ *
+ * kernel error messages are automatically translated into user-friendly
+ * explanations when the error kind is KERNEL_OPERATION.
+ */
+export declare function kernelCallRaw<T>(fn: () => T, code: string, message: string, kind?: BrepErrorKind): Result<T>;
+/**
+ * Wrap a kernel call that needs intermediate kernel allocations.
+ *
+ * A DisposalScope is created and passed to fn. The scope is disposed
+ * deterministically after fn returns or throws — ensuring no intermediate
+ * handles are leaked even on error paths.
+ *
+ * ```ts
+ * return kernelCallScoped(
+ *   (scope) => {
+ *     const axis = scope.register(makeKernelAx1(origin, dir));
+ *     return getKernel().revolveVec(...) // was: oc.BRepBuilderAPI_MakeRevol_1(shape.wrapped, axis).Shape();
+ *   },
+ *   BrepErrorCode.REVOLUTION_NOT_3D,
+ *   'Revolution failed'
+ * );
+ * ```
+ */
+export declare function kernelCallScoped(fn: (scope: DisposalScope) => KernelShape, code: string, message: string, kind?: BrepErrorKind): Result<AnyShape>;
+//# sourceMappingURL=kernelCall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelCall.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelCall.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,aAAa,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AA2C9C;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,EAAE,EAAE,MAAM,WAAW,EACrB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,aAAkC,GACvC,MAAM,CAAC,QAAQ,CAAC,CAalB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,EAAE,EAAE,MAAM,CAAC,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,aAAkC,GACvC,MAAM,CAAC,CAAC,CAAC,CAUX;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,WAAW,EACzC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,aAAkC,GACvC,MAAM,CAAC,QAAQ,CAAC,CAGlB"}

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

@@ -0,0 +1,154 @@
+/**
+ * Error handling helpers for kernel operations.
+ *
+ * Reduces boilerplate in *Fns.ts files by wrapping try/catch + castShape
+ * into a single call.
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { castResultShape } from './shapeTypes.js';
+import { ok, err } from './result.js';
+import { translateKernelError, getSuggestionForCode } from './errors.js';
+import { DisposalScope } from './disposal.js';
+function buildError(kind, code, message, cause, suggestion) {
+    const base = { kind, code, message, cause };
+    if (suggestion)
+        return { ...base, suggestion };
+    return base;
+}
+const errorFactories = {
+    KERNEL_OPERATION: (code, message, cause, suggestion) => buildError('KERNEL_OPERATION', code, message, cause, suggestion),
+    VALIDATION: (code, message, cause, suggestion) => buildError('VALIDATION', code, message, cause, suggestion),
+    TYPE_CAST: (code, message, cause, suggestion) => buildError('TYPE_CAST', code, message, cause, suggestion),
+    SKETCHER_STATE: (code, message, cause, suggestion) => buildError('SKETCHER_STATE', code, message, cause, suggestion),
+    MODULE_INIT: (code, message, cause, suggestion) => buildError('MODULE_INIT', code, message, cause, suggestion),
+    COMPUTATION: (code, message, cause, suggestion) => buildError('COMPUTATION', code, message, cause, suggestion),
+    IO: (code, message, cause, suggestion) => buildError('IO', code, message, cause, suggestion),
+    QUERY: (code, message, cause, suggestion) => buildError('QUERY', code, message, cause, suggestion),
+    // NB: UNSUPPORTED exists for Record<BrepErrorKind> exhaustiveness.
+    // Prefer explicit `return err(unsupportedError(...))` in adapter code (ADR-0006).
+    UNSUPPORTED: (code, message, cause, suggestion) => buildError('UNSUPPORTED', code, message, cause, suggestion),
+};
+/**
+ * Wrap a kernel call that returns an KernelShape, automatically casting
+ * the result into a branded AnyShape. On exception, returns an Err
+ * with the given error code and message.
+ *
+ * kernel error messages are automatically translated into user-friendly
+ * explanations when the error kind is KERNEL_OPERATION.
+ */
+export function kernelCall(fn, code, message, kind = 'KERNEL_OPERATION') {
+    try {
+        // castResultShape (not castShape): fn() returns a fresh kernel result the
+        // caller owns, so release its orphaned pre-downcast slot on the occt-wasm
+        // arena kernel. Identity-downcast kernels skip the release via the guard.
+        return ok(castResultShape(fn()));
+    }
+    catch (e) {
+        const rawMessage = e instanceof Error ? e.message : String(e);
+        const translatedMessage = kind === 'KERNEL_OPERATION' ? translateKernelError(rawMessage) : rawMessage;
+        const suggestion = getSuggestionForCode(code);
+        return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e, suggestion));
+    }
+}
+/**
+ * Wrap a kernel call that returns an arbitrary value. On exception,
+ * returns an Err with the given error code and message.
+ *
+ * kernel error messages are automatically translated into user-friendly
+ * explanations when the error kind is KERNEL_OPERATION.
+ */
+export function kernelCallRaw(fn, code, message, kind = 'KERNEL_OPERATION') {
+    try {
+        return ok(fn());
+    }
+    catch (e) {
+        const rawMessage = e instanceof Error ? e.message : String(e);
+        const translatedMessage = kind === 'KERNEL_OPERATION' ? translateKernelError(rawMessage) : rawMessage;
+        const suggestion = getSuggestionForCode(code);
+        return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e, suggestion));
+    }
+}
+/**
+ * Wrap a kernel call that needs intermediate kernel allocations.
+ *
+ * A DisposalScope is created and passed to fn. The scope is disposed
+ * deterministically after fn returns or throws — ensuring no intermediate
+ * handles are leaked even on error paths.
+ *
+ * ```ts
+ * return kernelCallScoped(
+ *   (scope) => {
+ *     const axis = scope.register(makeKernelAx1(origin, dir));
+ *     return getKernel().revolveVec(...) // was: oc.BRepBuilderAPI_MakeRevol_1(shape.wrapped, axis).Shape();
+ *   },
+ *   BrepErrorCode.REVOLUTION_NOT_3D,
+ *   'Revolution failed'
+ * );
+ * ```
+ */
+export function kernelCallScoped(fn, code, message, kind = 'KERNEL_OPERATION') {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const scope = __addDisposableResource(env_1, new DisposalScope(), false);
+        return kernelCall(() => fn(scope), code, message, kind);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+//# sourceMappingURL=kernelCall.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelCall.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelCall.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Error handling helpers for kernel operations.\n *\n * Reduces boilerplate in *Fns.ts files by wrapping try/catch + castShape\n * into a single call.\n */\n\nimport type { KernelShape } from '../kernel/types.js';\nimport type { AnyShape } from './shapeTypes.js';\nimport { castResultShape } from './shapeTypes.js';\nimport type { Result } from './result.js';\nimport { ok, err } from './result.js';\nimport type { BrepErrorKind, BrepError } from './errors.js';\nimport { translateKernelError, getSuggestionForCode } from './errors.js';\nimport { DisposalScope } from './disposal.js';\n\ntype ErrorFactory = (\n  code: string,\n  message: string,\n  cause?: unknown,\n  suggestion?: string\n) => BrepError;\n\nfunction buildError(\n  kind: BrepErrorKind,\n  code: string,\n  message: string,\n  cause?: unknown,\n  suggestion?: string\n): BrepError {\n  const base: BrepError = { kind, code, message, cause };\n  if (suggestion) return { ...base, suggestion };\n  return base;\n}\n\nconst errorFactories: Record<BrepErrorKind, ErrorFactory> = {\n  KERNEL_OPERATION: (code, message, cause, suggestion) =>\n    buildError('KERNEL_OPERATION', code, message, cause, suggestion),\n  VALIDATION: (code, message, cause, suggestion) =>\n    buildError('VALIDATION', code, message, cause, suggestion),\n  TYPE_CAST: (code, message, cause, suggestion) =>\n    buildError('TYPE_CAST', code, message, cause, suggestion),\n  SKETCHER_STATE: (code, message, cause, suggestion) =>\n    buildError('SKETCHER_STATE', code, message, cause, suggestion),\n  MODULE_INIT: (code, message, cause, suggestion) =>\n    buildError('MODULE_INIT', code, message, cause, suggestion),\n  COMPUTATION: (code, message, cause, suggestion) =>\n    buildError('COMPUTATION', code, message, cause, suggestion),\n  IO: (code, message, cause, suggestion) => buildError('IO', code, message, cause, suggestion),\n  QUERY: (code, message, cause, suggestion) =>\n    buildError('QUERY', code, message, cause, suggestion),\n  // NB: UNSUPPORTED exists for Record<BrepErrorKind> exhaustiveness.\n  // Prefer explicit `return err(unsupportedError(...))` in adapter code (ADR-0006).\n  UNSUPPORTED: (code, message, cause, suggestion) =>\n    buildError('UNSUPPORTED', code, message, cause, suggestion),\n};\n\n/**\n * Wrap a kernel call that returns an KernelShape, automatically casting\n * the result into a branded AnyShape. On exception, returns an Err\n * with the given error code and message.\n *\n * kernel error messages are automatically translated into user-friendly\n * explanations when the error kind is KERNEL_OPERATION.\n */\nexport function kernelCall(\n  fn: () => KernelShape,\n  code: string,\n  message: string,\n  kind: BrepErrorKind = 'KERNEL_OPERATION'\n): Result<AnyShape> {\n  try {\n    // castResultShape (not castShape): fn() returns a fresh kernel result the\n    // caller owns, so release its orphaned pre-downcast slot on the occt-wasm\n    // arena kernel. Identity-downcast kernels skip the release via the guard.\n    return ok(castResultShape(fn()));\n  } catch (e) {\n    const rawMessage = e instanceof Error ? e.message : String(e);\n    const translatedMessage =\n      kind === 'KERNEL_OPERATION' ? translateKernelError(rawMessage) : rawMessage;\n    const suggestion = getSuggestionForCode(code);\n    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e, suggestion));\n  }\n}\n\n/**\n * Wrap a kernel call that returns an arbitrary value. On exception,\n * returns an Err with the given error code and message.\n *\n * kernel error messages are automatically translated into user-friendly\n * explanations when the error kind is KERNEL_OPERATION.\n */\nexport function kernelCallRaw<T>(\n  fn: () => T,\n  code: string,\n  message: string,\n  kind: BrepErrorKind = 'KERNEL_OPERATION'\n): Result<T> {\n  try {\n    return ok(fn());\n  } catch (e) {\n    const rawMessage = e instanceof Error ? e.message : String(e);\n    const translatedMessage =\n      kind === 'KERNEL_OPERATION' ? translateKernelError(rawMessage) : rawMessage;\n    const suggestion = getSuggestionForCode(code);\n    return err(errorFactories[kind](code, `${message}: ${translatedMessage}`, e, suggestion));\n  }\n}\n\n/**\n * Wrap a kernel call that needs intermediate kernel allocations.\n *\n * A DisposalScope is created and passed to fn. The scope is disposed\n * deterministically after fn returns or throws — ensuring no intermediate\n * handles are leaked even on error paths.\n *\n * ```ts\n * return kernelCallScoped(\n *   (scope) => {\n *     const axis = scope.register(makeKernelAx1(origin, dir));\n *     return getKernel().revolveVec(...) // was: oc.BRepBuilderAPI_MakeRevol_1(shape.wrapped, axis).Shape();\n *   },\n *   BrepErrorCode.REVOLUTION_NOT_3D,\n *   'Revolution failed'\n * );\n * ```\n */\nexport function kernelCallScoped(\n  fn: (scope: DisposalScope) => KernelShape,\n  code: string,\n  message: string,\n  kind: BrepErrorKind = 'KERNEL_OPERATION'\n): Result<AnyShape> {\n  using scope = new DisposalScope();\n  return kernelCall(() => fn(scope), code, message, kind);\n}\n"]}

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

@@ -0,0 +1,17 @@
+/**
+ * Kernel error translation — maps cryptic kernel messages to user-friendly explanations.
+ *
+ * Extracted from errors.ts to separate pure type/constructor definitions
+ * from OCCT-specific regex matching logic.
+ */
+/** Look up an actionable suggestion for a given error code. */
+export declare function getSuggestionForCode(code: string): string | undefined;
+/**
+ * Translate an kernel error message into a user-friendly explanation.
+ * If no pattern matches, returns the original message.
+ *
+ * @param kernelMessage - The raw error message from kernel
+ * @returns User-friendly error message with actionable guidance
+ */
+export declare function translateKernelError(kernelMessage: string): string;
+//# sourceMappingURL=kernelErrorTranslation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelErrorTranslation.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelErrorTranslation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoGH,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAQlE"}

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

@@ -0,0 +1,98 @@
+/**
+ * Kernel error translation — maps cryptic kernel messages to user-friendly explanations.
+ *
+ * Extracted from errors.ts to separate pure type/constructor definitions
+ * from OCCT-specific regex matching logic.
+ */
+/**
+ * Common kernel error patterns and their user-friendly translations.
+ * Used by kernelCall to provide actionable error messages.
+ */
+const kernel_ERROR_PATTERNS = [
+    {
+        pattern: /invalid edge configuration|edges?.*(not|fail|invalid)/i,
+        translation: 'The edges may not form a continuous loop. Check that edges connect end-to-end without gaps.',
+    },
+    {
+        pattern: /BRepAlgoAPI.*failed|boolean.*operation.*failed/i,
+        translation: 'Boolean operation failed. Common causes: overlapping faces, zero-thickness geometry, or degenerate shapes. Try healing input shapes first.',
+    },
+    {
+        pattern: /fillet.*radius.*too.*large|fillet.*failed/i,
+        translation: 'Fillet operation failed. The radius may be too large for the selected edges. Try reducing the radius or check that edges have enough room.',
+    },
+    {
+        pattern: /chamfer.*failed|chamfer.*distance.*too.*large/i,
+        translation: 'Chamfer operation failed. The distance may be too large for the selected edges. Try reducing the distance or check edge geometry.',
+    },
+    {
+        pattern: /shell.*failed|offset.*failed/i,
+        translation: 'Shell/offset operation failed. The thickness may be too large, or the shape may have complex geometry. Try reducing thickness.',
+    },
+    {
+        pattern: /sweep.*failed|pipe.*failed/i,
+        translation: 'Sweep operation failed. Check that the profile and spine are compatible, and that the spine has no sharp twists or self-intersections.',
+    },
+    {
+        pattern: /loft.*failed/i,
+        translation: 'Loft operation failed. Profiles may be incompatible or have different orientations. Ensure profiles are ordered consistently.',
+    },
+    {
+        pattern: /extrude.*failed|prism.*failed/i,
+        translation: 'Extrusion failed. The profile may be invalid or self-intersecting. Check that the profile forms a valid closed wire.',
+    },
+    {
+        pattern: /revolve.*failed|revolution.*failed/i,
+        translation: 'Revolution operation failed. The profile may intersect the axis of revolution, or the angle may be invalid.',
+    },
+    {
+        pattern: /self.*intersect|self-intersect/i,
+        translation: 'Shape has self-intersections. The operation resulted in overlapping geometry. Simplify the input or adjust parameters.',
+    },
+    {
+        pattern: /degener|degenerat/i,
+        translation: 'Degenerate geometry detected. The shape has edges or faces with zero length/area. Check input geometry for collapsed elements.',
+    },
+    {
+        pattern: /BRepCheck.*fail|shape.*invalid|shape.*not.*valid/i,
+        translation: 'Shape validation failed. The resulting shape has invalid topology. Try healing the shape or checking input geometry.',
+    },
+];
+// ---------------------------------------------------------------------------
+// Per-error-code suggestions — actionable hints for the `suggestion` field
+// ---------------------------------------------------------------------------
+const ERROR_CODE_SUGGESTIONS = {
+    FUSE_FAILED: 'Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.',
+    CUT_FAILED: 'Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.',
+    FUSE_NOT_3D: 'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',
+    CUT_NOT_3D: 'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',
+    INTERSECT_NOT_3D: 'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',
+    SWEEP_FAILED: 'Ensure the spine curve has no sharp corners or self-intersections. Try simplifying the profile or using a smoother path.',
+    LOFT_FAILED: 'Check that all profiles have the same number of edges and consistent orientation. Try reordering profiles.',
+    FILLET_NOT_3D: 'The fillet radius may be too large for the selected edges. Try a smaller radius or check that adjacent faces have enough room.',
+    CHAMFER_NOT_3D: 'The chamfer distance may be too large. Try a smaller distance or check edge geometry.',
+    SHELL_NOT_3D: 'The shell thickness may be too large for the shape. Try reducing thickness or removing problematic faces.',
+    OFFSET_NOT_3D: 'The offset distance may be too large for the shape geometry. Try a smaller distance.',
+    DRAFT_FAILED: 'The draft angle may be too large or the selected faces incompatible. Try a smaller angle or different faces.',
+};
+/** Look up an actionable suggestion for a given error code. */
+export function getSuggestionForCode(code) {
+    return ERROR_CODE_SUGGESTIONS[code];
+}
+/**
+ * Translate an kernel error message into a user-friendly explanation.
+ * If no pattern matches, returns the original message.
+ *
+ * @param kernelMessage - The raw error message from kernel
+ * @returns User-friendly error message with actionable guidance
+ */
+export function translateKernelError(kernelMessage) {
+    for (const { pattern, translation } of kernel_ERROR_PATTERNS) {
+        if (pattern.test(kernelMessage)) {
+            return `${translation} (kernel: ${kernelMessage})`;
+        }
+    }
+    // No pattern matched — return original message
+    return kernelMessage;
+}
+//# sourceMappingURL=kernelErrorTranslation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelErrorTranslation.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/kernelErrorTranslation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,qBAAqB,GAA4D;IACrF;QACE,OAAO,EAAE,wDAAwD;QACjE,WAAW,EACT,6FAA6F;KAChG;IACD;QACE,OAAO,EAAE,iDAAiD;QAC1D,WAAW,EACT,4IAA4I;KAC/I;IACD;QACE,OAAO,EAAE,4CAA4C;QACrD,WAAW,EACT,4IAA4I;KAC/I;IACD;QACE,OAAO,EAAE,gDAAgD;QACzD,WAAW,EACT,mIAAmI;KACtI;IACD;QACE,OAAO,EAAE,+BAA+B;QACxC,WAAW,EACT,gIAAgI;KACnI;IACD;QACE,OAAO,EAAE,6BAA6B;QACtC,WAAW,EACT,wIAAwI;KAC3I;IACD;QACE,OAAO,EAAE,eAAe;QACxB,WAAW,EACT,+HAA+H;KAClI;IACD;QACE,OAAO,EAAE,gCAAgC;QACzC,WAAW,EACT,sHAAsH;KACzH;IACD;QACE,OAAO,EAAE,qCAAqC;QAC9C,WAAW,EACT,6GAA6G;KAChH;IACD;QACE,OAAO,EAAE,iCAAiC;QAC1C,WAAW,EACT,wHAAwH;KAC3H;IACD;QACE,OAAO,EAAE,oBAAoB;QAC7B,WAAW,EACT,gIAAgI;KACnI;IACD;QACE,OAAO,EAAE,mDAAmD;QAC5D,WAAW,EACT,sHAAsH;KACzH;CACF,CAAC;AAEF,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAE9E,MAAM,sBAAsB,GAAqC;IAC/D,WAAW,EACT,uHAAuH;IACzH,UAAU,EACR,uHAAuH;IACzH,WAAW,EACT,mHAAmH;IACrH,UAAU,EACR,mHAAmH;IACrH,gBAAgB,EACd,mHAAmH;IACrH,YAAY,EACV,0HAA0H;IAC5H,WAAW,EACT,4GAA4G;IAC9G,aAAa,EACX,gIAAgI;IAClI,cAAc,EACZ,uFAAuF;IACzF,YAAY,EACV,2GAA2G;IAC7G,aAAa,EACX,sFAAsF;IACxF,YAAY,EACV,8GAA8G;CACjH,CAAC;AAEF,+DAA+D;AAC/D,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,aAAqB;IACxD,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,qBAAqB,EAAE,CAAC;QAC7D,IAAI,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;YAChC,OAAO,GAAG,WAAW,aAAa,aAAa,GAAG,CAAC;QACrD,CAAC;IACH,CAAC;IACD,+CAA+C;IAC/C,OAAO,aAAa,CAAC;AACvB,CAAC","sourcesContent":["/**\n * Kernel error translation — maps cryptic kernel messages to user-friendly explanations.\n *\n * Extracted from errors.ts to separate pure type/constructor definitions\n * from OCCT-specific regex matching logic.\n */\n\n/**\n * Common kernel error patterns and their user-friendly translations.\n * Used by kernelCall to provide actionable error messages.\n */\nconst kernel_ERROR_PATTERNS: ReadonlyArray<{ pattern: RegExp; translation: string }> = [\n  {\n    pattern: /invalid edge configuration|edges?.*(not|fail|invalid)/i,\n    translation:\n      'The edges may not form a continuous loop. Check that edges connect end-to-end without gaps.',\n  },\n  {\n    pattern: /BRepAlgoAPI.*failed|boolean.*operation.*failed/i,\n    translation:\n      'Boolean operation failed. Common causes: overlapping faces, zero-thickness geometry, or degenerate shapes. Try healing input shapes first.',\n  },\n  {\n    pattern: /fillet.*radius.*too.*large|fillet.*failed/i,\n    translation:\n      'Fillet operation failed. The radius may be too large for the selected edges. Try reducing the radius or check that edges have enough room.',\n  },\n  {\n    pattern: /chamfer.*failed|chamfer.*distance.*too.*large/i,\n    translation:\n      'Chamfer operation failed. The distance may be too large for the selected edges. Try reducing the distance or check edge geometry.',\n  },\n  {\n    pattern: /shell.*failed|offset.*failed/i,\n    translation:\n      'Shell/offset operation failed. The thickness may be too large, or the shape may have complex geometry. Try reducing thickness.',\n  },\n  {\n    pattern: /sweep.*failed|pipe.*failed/i,\n    translation:\n      'Sweep operation failed. Check that the profile and spine are compatible, and that the spine has no sharp twists or self-intersections.',\n  },\n  {\n    pattern: /loft.*failed/i,\n    translation:\n      'Loft operation failed. Profiles may be incompatible or have different orientations. Ensure profiles are ordered consistently.',\n  },\n  {\n    pattern: /extrude.*failed|prism.*failed/i,\n    translation:\n      'Extrusion failed. The profile may be invalid or self-intersecting. Check that the profile forms a valid closed wire.',\n  },\n  {\n    pattern: /revolve.*failed|revolution.*failed/i,\n    translation:\n      'Revolution operation failed. The profile may intersect the axis of revolution, or the angle may be invalid.',\n  },\n  {\n    pattern: /self.*intersect|self-intersect/i,\n    translation:\n      'Shape has self-intersections. The operation resulted in overlapping geometry. Simplify the input or adjust parameters.',\n  },\n  {\n    pattern: /degener|degenerat/i,\n    translation:\n      'Degenerate geometry detected. The shape has edges or faces with zero length/area. Check input geometry for collapsed elements.',\n  },\n  {\n    pattern: /BRepCheck.*fail|shape.*invalid|shape.*not.*valid/i,\n    translation:\n      'Shape validation failed. The resulting shape has invalid topology. Try healing the shape or checking input geometry.',\n  },\n];\n\n// ---------------------------------------------------------------------------\n// Per-error-code suggestions — actionable hints for the `suggestion` field\n// ---------------------------------------------------------------------------\n\nconst ERROR_CODE_SUGGESTIONS: Readonly<Record<string, string>> = {\n  FUSE_FAILED:\n    'Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.',\n  CUT_FAILED:\n    'Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.',\n  FUSE_NOT_3D:\n    'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',\n  CUT_NOT_3D:\n    'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',\n  INTERSECT_NOT_3D:\n    'The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.',\n  SWEEP_FAILED:\n    'Ensure the spine curve has no sharp corners or self-intersections. Try simplifying the profile or using a smoother path.',\n  LOFT_FAILED:\n    'Check that all profiles have the same number of edges and consistent orientation. Try reordering profiles.',\n  FILLET_NOT_3D:\n    'The fillet radius may be too large for the selected edges. Try a smaller radius or check that adjacent faces have enough room.',\n  CHAMFER_NOT_3D:\n    'The chamfer distance may be too large. Try a smaller distance or check edge geometry.',\n  SHELL_NOT_3D:\n    'The shell thickness may be too large for the shape. Try reducing thickness or removing problematic faces.',\n  OFFSET_NOT_3D:\n    'The offset distance may be too large for the shape geometry. Try a smaller distance.',\n  DRAFT_FAILED:\n    'The draft angle may be too large or the selected faces incompatible. Try a smaller angle or different faces.',\n};\n\n/** Look up an actionable suggestion for a given error code. */\nexport function getSuggestionForCode(code: string): string | undefined {\n  return ERROR_CODE_SUGGESTIONS[code];\n}\n\n/**\n * Translate an kernel error message into a user-friendly explanation.\n * If no pattern matches, returns the original message.\n *\n * @param kernelMessage - The raw error message from kernel\n * @returns User-friendly error message with actionable guidance\n */\nexport function translateKernelError(kernelMessage: string): string {\n  for (const { pattern, translation } of kernel_ERROR_PATTERNS) {\n    if (pattern.test(kernelMessage)) {\n      return `${translation} (kernel: ${kernelMessage})`;\n    }\n  }\n  // No pattern matched — return original message\n  return kernelMessage;\n}\n"]}

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

@@ -0,0 +1,41 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,68 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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}"]}

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

@@ -0,0 +1,62 @@
+/**
+ * Pure plane operations — replaces the old Plane class methods.
+ * All functions return new immutable Plane objects.
+ */
+import type { Vec3, Vec2, PointInput } from './types.js';
+import type { Plane, PlaneName, PlaneInput } from './planeTypes.js';
+import { type Result } from './result.js';
+/**
+ * Create a {@link Plane} from an origin, optional X direction, and a normal.
+ *
+ * If `xDirection` is omitted, the X axis is derived automatically via kernel `gp_Ax3`.
+ *
+ * @param origin - Origin point of the plane.
+ * @param xDirection - Explicit X axis direction, or `null` to auto-derive.
+ * @param normal - Plane normal (Z direction).
+ * @throws If the normal or derived xDir is zero-length.
+ */
+export declare function createPlane(origin: Vec3, xDirection?: Vec3 | null, normal?: Vec3): Plane;
+/**
+ * Create a standard named plane with an optional origin offset.
+ *
+ * @param name - One of the predefined {@link PlaneName} values.
+ * @param sourceOrigin - Origin point, or a scalar offset along the plane normal.
+ * @returns `Ok<Plane>` on success, or `Err` if the name is unknown.
+ */
+export declare function createNamedPlane(name: PlaneName, sourceOrigin?: PointInput | number): Result<Plane>;
+/**
+ * Resolve a {@link PlaneInput} to a concrete {@link Plane}.
+ *
+ * @returns `Ok<Plane>` on success, or `Err` if the named plane cannot be resolved.
+ */
+export declare function resolvePlane(input: PlaneInput, origin?: PointInput | number): Result<Plane>;
+/**
+ * Create or copy a {@link Plane}.
+ *
+ * When called with a `Plane` object, returns a shallow copy.
+ * When called with a `PlaneName` string (or no arguments), resolves the named
+ * plane with an optional origin offset.
+ *
+ * @param plane - A `Plane` object to copy, or a `PlaneName` string to resolve.
+ * @param origin - Origin point or scalar offset along the plane normal.
+ * @default plane `'XY'`
+ */
+declare function makePlane(plane: Plane): Plane;
+declare function makePlane(plane?: PlaneName, origin?: PointInput | number): Plane;
+export { makePlane };
+/** Convert 2D local coordinates to 3D world coordinates on the plane. */
+export declare function planeToWorld(plane: Plane, local: Vec2): Vec3;
+/**
+ * Convert 3D world coordinates to 2D local coordinates on the plane.
+ */
+export declare function planeToLocal(plane: Plane, world: Vec3): Vec2;
+/** Translate a plane by a vector. */
+export declare function translatePlane(plane: Plane, offset: Vec3): Plane;
+/**
+ * Pivot a plane by rotating its axes around a world-space axis.
+ *
+ * @param angleDeg - Rotation angle in **degrees**.
+ * @param axis - World-space axis to rotate around.
+ */
+export declare function pivotPlane(plane: Plane, angleDeg: number, axis?: Vec3): Plane;
+//# sourceMappingURL=planeOps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planeOps.d.ts","sourceRoot":"","sources":["../../../../src/vendored/brepjs/core/planeOps.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEzD,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAYpE,OAAO,EAAE,KAAK,MAAM,EAAmB,MAAM,aAAa,CAAC;AAO3D;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,IAAI,EACZ,UAAU,GAAE,IAAI,GAAG,IAAW,EAC9B,MAAM,GAAE,IAAgB,GACvB,KAAK,CA+BP;AAqBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,EACf,YAAY,GAAE,UAAU,GAAG,MAAkB,GAC5C,MAAM,CAAC,KAAK,CAAC,CAWf;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAK3F;AAMD;;;;;;;;;;GAUG;AACH,iBAAS,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;AACxC,iBAAS,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,KAAK,CAAC;AAU3E,OAAO,EAAE,SAAS,EAAE,CAAC;AAMrB,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CAG5D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CAG5D;AAMD,qCAAqC;AACrC,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAG,KAAK,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,IAAgB,GAAG,KAAK,CAMxF"}