@metamesh/modeling 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @metamesh/modeling
 
+## 0.13.0
+
+### Minor Changes
+
+- 2ebe03f: Ship exact-version offline documentation and a development-only authoring CLI for semantic
+  checking, generation, captured geometry inspection, and explicit Chromium previews. Use exact
+  package versions in documentation metadata and reject unsupported authoring artifact formats.
+  Provide generated command help and strict per-command argument validation, and enforce semantic
+  checking even when the consumer's TypeScript configuration disables it.
+
+  Publish lightweight model and Generator testing helpers as `@metamesh/testkit`. Move the
+  `metamesh` executable and Node authoring API into `@metamesh/cli`, which owns compiler, bundler,
+  renderer, and browser dependencies. Remove the former package name and authoring entry from
+  Testkit without compatibility aliases.
+
+- 7e1b75d: Simplify modeling authoring with `polygon` construction, shared bounds and vector text fitting,
+  Section patterns, pure pattern transforms, and explicit profile closure and part layout helpers.
+  Zero-sized round, chamfer, and smooth treatments preserve untreated geometry.
+
+  Replace the public geometry vocabulary with `Vector2`, `Vector3`, `Contour`, `Polygon`, and
+  `Region`, and use canonical `Bounds2` and `Bounds3` throughout. Remove retired constructor and
+  type names. Bundles require runtime major 5 and the generation realm uses protocol 5; older
+  runtime packages reject before execution. The package envelope remains format 4.
+
+- 3139981: Allow generation callbacks to return a single `part(...)` declaration or a readonly array of parts.
+  Existing array returns remain supported, and engine snapshots continue to expose a parts array.
+
 ## 0.12.0
 
 ### Minor Changes

package/README.md

@@ -1,48 +1,62 @@
 # `@metamesh/modeling`
 
-Build parametric 3D parts with TypeScript and export the finished meshes to 3MF. Use Modeling in
-Node applications, browser Workers, or MetaMesh Generators, with no SDK or Testkit required.
+Build parametric 3D parts in TypeScript. Combine solids, work with pure geometry, and export 3MF
+from Node applications, browser Workers, or MetaMesh Generators.
 
 > **Preview:** `0.x` minor releases may break compatibility. Patches remain compatible within the
-> same minor line. Stable support requires an explicit `1.0.0` review.
+> same minor line.
 
-## Start modeling
+## Installation
 
 ```bash
 pnpm add @metamesh/modeling
 ```
 
-Initialize an engine, then build and export a plate with a hole:
+Modeling works on its own; the Generator SDK and Testkit are optional.
+
+## Start modeling
+
+Build a plate with a hole, then export its finished geometry:
 
 ```ts
 import { box, cylinder, generate } from "@metamesh/modeling";
 import { createModelEngine } from "@metamesh/modeling/engine";
 
-const engine = await createModelEngine();
 const model = generate<Record<never, never>>(({ part }) => {
   const body = box({ size: [30, 20, 6] });
   const bore = cylinder({ height: 8, radius: 3, sizing: "face" });
-  return [part("plate", { geometry: body.subtract([bore]), color: "#67e8f9" })];
+  return part("plate", body.subtract([bore]));
 });
+
+const engine = await createModelEngine();
 const session = engine.createSession(model, { resolution: { maxChordError: 0.025 } });
-const snapshot = session.run({});
-const bytes = await engine.export3mf(snapshot.parts, { name: "Plate" });
-snapshot.dispose();
-session.dispose();
+try {
+  const snapshot = session.run({});
+  try {
+    const bytes = await engine.export3mf(snapshot.parts, { name: "Plate" });
+    // Save or send the 3MF bytes.
+  } finally {
+    snapshot.dispose();
+  }
+} finally {
+  session.dispose();
+}
 ```
 
-Constructors and fluent shape methods declare immutable recipes inside synchronous generation.
-Use shape methods for transforms, subtraction, and finishing; collection operations such as
-`union`, patterns, and observations remain functions. Calls apply in written order about the origin.
-A method preserves its input; no-op operations may reuse a handle. A session owns optional
-computed caches; captured snapshots stay usable after the session is disposed. Keep the finalized
-snapshot for rendering or export, then dispose it. For browser WASM setup and host lifecycle, follow
-[Run Modeling in your application](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/hosting.mdx).
+Generation is synchronous. Return a single `part(...)` or a readonly array of parts. Shape constructors
+and methods create immutable recipes; the engine evaluates them into a snapshot for rendering or
+export. Sessions own reusable work, while snapshots remain usable after their session is disposed.
+Dispose both when finished. Export uses the captured geometry without running the model again.
+
+Lengths use millimetres and modeling rotations use degrees. Physical resolution controls curve
+sampling for both preview and manufacturing output. See the
+[hosting guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/hosting.mdx)
+for browser WASM setup, resource limits, and lifecycle details.
 
 ## Reuse unchanged work
 
-Caching is optional. A named computation tracks parameter and other computation reads; part
-placement and color stay separate from its geometry:
+Use optional `computed` values for expensive geometry or data. Keep ordinary arithmetic and part
+placement simple:
 
 ```ts
 const model = generate<{ height: number; gap: number }>(({ params, computed, part }) => {
@@ -51,67 +65,41 @@ const model = generate<{ height: number; gap: number }>(({ params, computed, par
 });
 ```
 
-Changing `gap` reuses the body's validated geometry. Changing `height` recomputes it. Read parameters
-and computed readers inside the callback; locals calculated there keep those reads tracked.
-For changing values prepared outside, add a dependency array:
-
-```ts
-const { height } = params;
-const body = computed("body", () => box({ size: [10, 10, height] }), [height]);
-```
+Changing `gap` reuses the body's geometry; changing `height` recomputes it. Read parameters and
+other computed readers inside the callback so their dependencies are tracked. Changing outer
+captures need an explicit dependency array. Callbacks are pure and synchronous; cached data is
+immutable. Use `immutableBuffer` and `immutableMesh` for cached typed arrays and meshes.
 
-Both forms track synchronous parameter and reader calls inside the callback. An earlier parameter
-value or computed result carries no dependency into a later callback unless listed explicitly.
-The array supplements automatic tracking; even `[]` still tracks reads inside the callback.
-Entries compare with `Object.is`, without deep comparisons. Objects and arrays must be deeply
-immutable; parameter snapshots and computed results already satisfy this contract. Fresh objects
-still cause cache misses, so prefer scalar inputs and create temporary options inside the callback.
-Computations are pure and synchronous; ordinary generation without caching remains supported.
-
-Capture cached numeric arrays with `immutableBuffer(values)`: read `length` or `at(index)`, and
-call `copy()` for an owned mutable typed array. Capture cached meshes with `immutableMesh(mesh)`
-and pass their readers directly to `part`. Computed results and dependencies reject raw typed arrays;
-ordinary transient mesh inputs, snapshots, and Worker output still use normal typed arrays.
-
-The optional session setting `verifyCache: true` reruns callbacks on cache hits and compares bounded
-data and recipes to diagnose observable missing dependencies. It can reject unsupported or large
-comparisons and cannot prove arbitrary JavaScript; production caching leaves this probe disabled.
-
-For expensive geometry followed by adjustable cuts or Booleans, put the base and finishing stage
-in separate computations. Sessions can retain the evaluated base privately, preserving native
-precision when it becomes an operand in a later run. Retention is bounded and optional; eviction
-rebuilds the original recipe. Clear or dispose the session to release retained native geometry.
-
-Use `assert(condition, message)` for a constraint that stops the revision and `warn(message)` for
-nonblocking guidance. Hosts bind prepared deterministic capabilities through session `services`.
-`validateModel` checks declarations and reached assertions without initializing a kernel; checks
-that observe geometry use an initialized session's `validate` method.
+The [computed-value guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/code-project-contract.mdx)
+covers dependency tracking, immutable data, cache verification, and part placement.
 
 ## API discovery and ownership
 
-| Import                                                                                                                                      | Use it for                                                          |
-| ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
-| [`@metamesh/modeling`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/model/index.mdx)             | Fluent solids and sections, constructors, and collection operations |
-| [`@metamesh/modeling/geometry`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/geometry/index.mdx) | Pure paths, profiles, meshes, and calculations                      |
-| [`@metamesh/modeling/engine`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/engine/index.mdx)     | Sessions, snapshots, limits, and 3MF export                         |
-| [`@metamesh/modeling/text`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/text/index.mdx)         | Optional font preparation and vector layouts                        |
+| Import                                                                                                                                      | Use it for                                            |
+| ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
+| [`@metamesh/modeling`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/model/index.mdx)             | Solids, sections, transforms, and modeling operations |
+| [`@metamesh/modeling/geometry`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/geometry/index.mdx) | Pure paths, profiles, meshes, and calculations        |
+| [`@metamesh/modeling/engine`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/engine/index.mdx)     | Sessions, snapshots, limits, and 3MF export           |
+| [`@metamesh/modeling/text`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/text/index.mdx)         | Optional font preparation and vector layouts          |
 
 ## Documentation
 
-- [Geometry concepts](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-package.mdx) — modules, coordinates, resolution, and supported modeling paths.
-- [Geometry recipes](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-recipes.mdx) — worked examples for primitives, sweeps, lofts, and repeated parts.
-- [Font preparation](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/fonts.mdx) — supply exact font bytes outside Studio.
-
-The public docs are being prepared for `https://metamesh.studio/docs`. Until launch, use the
-repository links above or [run Web locally](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/README.md#local-use). Exact options,
-constraints, and examples live in source docblocks and the API reference generated from them.
+The installed package exposes `@metamesh/modeling/docs/manifest.json`: an exact-version index of
+plain Markdown guides and every public API symbol. Resolve that export from your project to find
+the documentation beside your installed release. Its paths are relative to the manifest.
+With Testkit installed, use `pnpm exec metamesh docs search "your topic"` and
+`pnpm exec metamesh docs show DOCUMENT_ID` for bounded offline lookup. Start with
+`modeling/guide/concepts` and `modeling/guide/hosting` when choosing an execution environment.
 
-## Contributing
+- [Geometry concepts](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-package.mdx) — coordinates, resolution, and supported modeling paths.
+- [Geometry recipes](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-recipes.mdx) — primitives, sweeps, lofts, text, SVG, and booleans.
+- [Font preparation](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/fonts.mdx) — prepare exact font bytes outside Studio.
 
-Start with [Update the Modeling API](https://github.com/JasonKoolman/metamesh/blob/main/docs/guides/update-the-geometry-api.md) and the
-[workspace instructions](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/AGENTS.md) for checks and reference generation. Internal dependency and
-execution boundaries live in [architecture](https://github.com/JasonKoolman/metamesh/blob/main/docs/architecture.md#modeling-library-and-execution).
+Until the public documentation site launches, use these repository guides or
+[run the docs locally](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/README.md#local-use).
+For package development, see [Contributing](https://github.com/JasonKoolman/metamesh/blob/main/CONTRIBUTING.md).
 
 ## License
 
-Apache-2.0; see [LICENSE](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/LICENSE) and [THIRD_PARTY_NOTICES.md](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/THIRD_PARTY_NOTICES.md).
+[Apache-2.0](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/LICENSE).
+Bundled dependencies are listed in [Third-party notices](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/THIRD_PARTY_NOTICES.md).

package/dist/api/engine.d.ts

@@ -1,139 +1,155 @@
 import type { TriangleMesh } from "@metamesh/modeling/geometry";
-import type { FinalizedModel, FinalizedPart, GenerationDiagnostic, GeometryResolution, ModelingLimits, ModelProgram, Vec3 } from "@metamesh/modeling";
+import type {
+  FinalizedModel,
+  FinalizedPart,
+  GenerationDiagnostic,
+  GeometryResolution,
+  ModelingLimits,
+  ModelProgram,
+  Vector3,
+} from "@metamesh/modeling";
 /** Default host resource ceilings for parts, vertices, triangles, and transferable bytes. */
 declare const defaultModelingLimits: Readonly<ModelingLimits>;
 
-
 /** Execution settings supplied by the host, independently of generator metadata. */
 export interface GenerationOptions {
-    /** Optional bounded intersection and nested-shell checks; defaults to indexed topology validation. */
-    readonly meshValidation?: "topology" | "solid";
-    /** Per-build limits, no larger than the configured engine ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-    /** Physical sampling defaults; operation options and exact counts override these. */
-    readonly resolution?: GeometryResolution;
-    /** Optional bounded planar cleanup; unsupported candidates preserve the original part. */
-    readonly meshTopologyMode?: "original" | "optimized";
+  /** Optional bounded intersection and nested-shell checks; defaults to indexed topology validation. */
+  readonly meshValidation?: "topology" | "solid";
+  /** Per-build limits, no larger than the configured engine ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+  /** Physical sampling defaults; operation options and exact counts override these. */
+  readonly resolution?: GeometryResolution;
+  /** Optional bounded planar cleanup; unsupported candidates preserve the original part. */
+  readonly meshTopologyMode?: "original" | "optimized";
 }
 /**
  * Host engine. No native values or manually disposable handles are exposed.
  */
 export interface ModelEngine {
-    /** Immutable resource ceilings selected when this engine was initialized. */
-    readonly limits: ModelingLimits;
-    /** Creates isolated caches; prepared service capabilities remain fixed for its lifetime. */
-    createSession<P, S>(program: ModelProgram<P, S>, ...options: keyof S extends never ? [options?: SessionOptions<S>] : [options: SessionOptions<S> & {
-        readonly services: S;
-    }]): ModelSession<P>;
-    /** Serializes already finalized mesh parts; never prepares or builds a generator again. */
-    export3mf(parts: readonly ExportMeshPart[], options?: Export3mfOptions): Promise<ArrayBuffer>;
+  /** Immutable resource ceilings selected when this engine was initialized. */
+  readonly limits: ModelingLimits;
+  /** Creates isolated caches; prepared service capabilities remain fixed for its lifetime. */
+  createSession<P, S>(
+    program: ModelProgram<P, S>,
+    ...options: keyof S extends never
+      ? [options?: SessionOptions<S>]
+      : [
+          options: SessionOptions<S> & {
+            readonly services: S;
+          },
+        ]
+  ): ModelSession<P>;
+  /** Serializes already finalized mesh parts; never prepares or builds a generator again. */
+  export3mf(
+    parts: readonly ExportMeshPart[],
+    options?: Export3mfOptions,
+  ): Promise<ArrayBuffer>;
 }
 /** Fixed generation policy and deterministic host capabilities for one model session. */
-export interface SessionOptions<S = Record<never, never>> extends GenerationOptions {
-    /** Host-owned synchronous capabilities, required when declared by the program. The original
-     * environment is retained; its behavior and assets must remain deterministic and fixed for
-     * this session. Equivalent function wrappers do not constitute an asset revision.
-     */
-    readonly services?: S;
-    /** Enables reuse; defaults to true. Set false for uncached output equivalence checks. */
-    readonly cache?: boolean;
-    /** Development-only cache-hit probe: reruns pure callbacks and compares bounded data/recipes.
-     * Unsupported closures or large results fail explicitly; this cannot prove arbitrary JavaScript.
-     */
-    readonly verifyCache?: boolean;
+export interface SessionOptions<
+  S = Record<never, never>,
+> extends GenerationOptions {
+  /** Host-owned synchronous capabilities, required when declared by the program. The original
+   * environment is retained; its behavior and assets must remain deterministic and fixed for
+   * this session. Equivalent function wrappers do not constitute an asset revision.
+   */
+  readonly services?: S;
+  /** Enables reuse; defaults to true. Set false for uncached output equivalence checks. */
+  readonly cache?: boolean;
+  /** Development-only cache-hit probe: reruns pure callbacks and compares bounded data/recipes.
+   * Unsupported closures or large results fail explicitly; this cannot prove arbitrary JavaScript.
+   */
+  readonly verifyCache?: boolean;
 }
 /** Validated local geometry resource; accessors return owned buffer copies. */
 export interface GeometryResource extends TriangleMesh {
-    /** Session-scoped immutable resource identity, stable while geometry is reused. */
-    readonly id: string;
-    /** Immutable resource revision; a new resource receives a new identity. */
-    readonly revision: number;
-    /** Facts for the exact local manufacturing buffers. */
-    readonly measurements: FinalizedPart["measurements"];
+  /** Session-scoped immutable resource identity, stable while geometry is reused. */
+  readonly id: string;
+  /** Immutable resource revision; a new resource receives a new identity. */
+  readonly revision: number;
+  /** Facts for the exact local manufacturing buffers. */
+  readonly measurements: FinalizedPart["measurements"];
 }
 /** A world-space manufacturing part plus its reusable local renderer resource. */
 export interface SnapshotPart extends FinalizedPart {
-    /** Validated geometry in local coordinates, independent of placement and appearance. */
-    readonly geometry: GeometryResource;
-    /** XYZ translation in millimetres after rotation. */
-    readonly position: Vec3;
-    /** Fixed global X, then Y, then Z rotation in degrees. */
-    readonly rotation: Vec3;
+  /** Validated geometry in local coordinates, independent of placement and appearance. */
+  readonly geometry: GeometryResource;
+  /** XYZ translation in millimetres after rotation. */
+  readonly position: Vector3;
+  /** Fixed global X, then Y, then Z rotation in degrees. */
+  readonly rotation: Vector3;
 }
 /** Captured immutable revision; disposal never changes another snapshot or an in-flight export. */
 export interface ModelSnapshot extends FinalizedModel {
-    /** Ordered world-space parts, each referring to reusable local geometry. */
-    readonly parts: readonly SnapshotPart[];
-    /** Nonblocking diagnostics emitted for this revision. */
-    readonly diagnostics: readonly GenerationDiagnostic[];
-    /** Known dependency graph; outer reads remain conservative model-wide dependencies. */
-    readonly dependencies: ModelDependencies;
-    /** Releases this snapshot's references; idempotent, further access is invalid. */
-    dispose(): void;
+  /** Ordered world-space parts, each referring to reusable local geometry. */
+  readonly parts: readonly SnapshotPart[];
+  /** Nonblocking diagnostics emitted for this revision. */
+  readonly diagnostics: readonly GenerationDiagnostic[];
+  /** Known dependency graph; outer reads remain conservative model-wide dependencies. */
+  readonly dependencies: ModelDependencies;
+  /** Releases this snapshot's references; idempotent, further access is invalid. */
+  dispose(): void;
 }
 /** Known dependencies for inspection; plain JavaScript bindings do not reveal their parameter origin. */
 export interface ModelDependencies {
-    /** Parameter keys read outside computed callbacks, affecting structure or ordinary code. */
-    readonly modelParameters: readonly string[];
-    /** Direct dependencies recorded by successfully evaluated computations. */
-    readonly computations: readonly {
-        /** Session-local computation identity. */
-        readonly id: string;
-        /** Direct top-level parameter reads. */
-        readonly parameters: readonly string[];
-        /** Direct computed-reader dependencies. */
-        readonly computations: readonly string[];
-    }[];
-    /** Part reader roots and known transitive parameter dependencies. */
-    readonly parts: readonly {
-        /** Stable semantic output part identity. */
-        readonly id: string;
-        /** Computed readers supplied as geometry or placement roots. */
-        readonly computations: readonly string[];
-        /** Known transitive parameter dependencies through these roots. */
-        readonly parameters: readonly string[];
-    }[];
+  /** Parameter keys read outside computed callbacks, affecting structure or ordinary code. */
+  readonly modelParameters: readonly string[];
+  /** Direct dependencies recorded by successfully evaluated computations. */
+  readonly computations: readonly {
+    /** Session-local computation identity. */
+    readonly id: string;
+    /** Direct top-level parameter reads. */
+    readonly parameters: readonly string[];
+    /** Direct computed-reader dependencies. */
+    readonly computations: readonly string[];
+  }[];
+  /** Part reader roots and known transitive parameter dependencies. */
+  readonly parts: readonly {
+    /** Stable semantic output part identity. */
+    readonly id: string;
+    /** Computed readers supplied as geometry or placement roots. */
+    readonly computations: readonly string[];
+    /** Known transitive parameter dependencies through these roots. */
+    readonly parameters: readonly string[];
+  }[];
 }
 /** Stateful execution owner; a failed revision cannot change previously returned snapshots. */
 export interface ModelSession<P> {
-    /** Generates an atomic manufacturing snapshot or throws; parameters are copied and frozen. */
-    run(params: Readonly<P>): ModelSnapshot;
-    /** Runs declaration and reached assertions without realizing returned parts. */
-    validate(params: Readonly<P>): readonly GenerationDiagnostic[];
-    /** Clears optional caches without invalidating captured snapshots. */
-    clearCache(): void;
-    /** Releases session ownership; idempotent, captured snapshots remain usable. */
-    dispose(): void;
+  /** Generates an atomic manufacturing snapshot or throws; parameters are copied and frozen. */
+  run(params: Readonly<P>): ModelSnapshot;
+  /** Runs declaration and reached assertions without realizing returned parts. */
+  validate(params: Readonly<P>): readonly GenerationDiagnostic[];
+  /** Clears optional caches without invalidating captured snapshots. */
+  clearCache(): void;
+  /** Releases session ownership; idempotent, captured snapshots remain usable. */
+  dispose(): void;
 }
 /**
  * Manufacturing buffers accepted by the snapshot exporter.
  */
 export interface ExportMeshPart extends TriangleMesh {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Optional six-digit hex RGB display color. */
-    readonly color?: string;
+  /** Stable canonical lowercase identity; unique within the containing topology or output. */
+  readonly id: string;
+  /** Optional six-digit hex RGB display color. */
+  readonly color?: string;
 }
 /**
  * Completed-snapshot serialization settings; filename selection belongs to the host.
  */
 export interface Export3mfOptions {
-    /** Optional bounded geometric solid checks on captured buffers; defaults to indexed topology validation. */
-    readonly meshValidation?: "topology" | "solid";
-    /** Document display name; defaults to MetaMesh model. */
-    readonly name?: string;
+  /** Optional bounded geometric solid checks on captured buffers; defaults to indexed topology validation. */
+  readonly meshValidation?: "topology" | "solid";
+  /** Document display name; defaults to MetaMesh model. */
+  readonly name?: string;
 }
 /** Kernel asset initialization. Networking and Worker ownership remain with the host. */
 export interface ModelEngineOptions {
-    /** Resolves the kernel's WASM asset. Browser hosts supply their bundled asset URL. */
-    readonly locateFile?: () => string;
-    /** Trusted application ceilings. Builds may lower them; generators receive no engine. */
-    readonly limits?: Partial<ModelingLimits>;
+  /** Resolves the kernel's WASM asset. Browser hosts supply their bundled asset URL. */
+  readonly locateFile?: () => string;
+  /** Trusted application ceilings. Builds may lower them; generators receive no engine. */
+  readonly limits?: Partial<ModelingLimits>;
 }
 
-
-
-
 export { defaultModelingLimits };
 /** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
 export declare const modelingWasmUrl: string;
@@ -142,9 +158,17 @@ export declare const modelingWasmUrl: string;
  * Runs declaration and immediate assertions without initializing a kernel or finalizing parts.
  * Geometry observations require an initialized session's `validate` method instead.
  */
-export declare function validateModel<P, S>(program: ModelProgram<P, S>, params: Readonly<P>, ...settings: keyof S extends never ? [options?: SessionOptions<S>] : [options: SessionOptions<S> & {
-    readonly services: S;
-}]): readonly GenerationDiagnostic[];
+export declare function validateModel<P, S>(
+  program: ModelProgram<P, S>,
+  params: Readonly<P>,
+  ...settings: keyof S extends never
+    ? [options?: SessionOptions<S>]
+    : [
+        options: SessionOptions<S> & {
+          readonly services: S;
+        },
+      ]
+): readonly GenerationDiagnostic[];
 /**
  * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
  *
@@ -168,5 +192,7 @@ export declare function validateModel<P, S>(program: ModelProgram<P, S>, params:
  * }
  * ```
  */
-export declare function createModelEngine(options?: ModelEngineOptions): Promise<ModelEngine>;
+export declare function createModelEngine(
+  options?: ModelEngineOptions,
+): Promise<ModelEngine>;
 export type { ModelingLimits };