@metamesh/testkit 0.0.0-stage → 0.13.0

package/CHANGELOG.md

@@ -0,0 +1,225 @@
+# @metamesh/testkit
+
+## 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.
+
+### Patch Changes
+
+- Updated dependencies [2ebe03f]
+- Updated dependencies [7e1b75d]
+- Updated dependencies [3139981]
+  - @metamesh/modeling@0.13.0
+  - @metamesh/generator-sdk@0.13.0
+
+## 0.12.0
+
+### Patch Changes
+
+- Updated dependencies [45d2617]
+  - @metamesh/modeling@0.12.0
+  - @metamesh/generator-sdk@0.12.0
+
+## 0.11.0
+
+### Minor Changes
+
+- b5da778: Replace prepare/build with typed generation programs, optional computed values and authoritative
+  part placement. Add isolated session caches and deferred geometry with explicit snapshot ownership.
+  Expose immutable fluent Solid and Section methods for transforms, subtraction, finishing, and
+  Section-to-Solid construction, replacing the corresponding standalone operations and public
+  context facade. Generator packages require format 4 and runtime 4; previous executable contracts are unsupported.
+
+### Patch Changes
+
+- 88f5336: Correct immutable cache comparisons, recapture mutable mesh inputs on every run, and preserve
+  session ownership during concurrent Testkit operations. Reject unsupported hidden data fields
+  instead of silently dropping them, and reuse native operation contexts during recipe evaluation.
+- Updated dependencies [88f5336]
+- Updated dependencies [6c90e9d]
+- Updated dependencies [b5da778]
+- Updated dependencies [60c458f]
+- Updated dependencies [d69836c]
+- Updated dependencies [bfb7a63]
+- Updated dependencies [a1f5aba]
+- Updated dependencies [d4ffce7]
+  - @metamesh/modeling@0.11.0
+  - @metamesh/generator-sdk@0.11.0
+
+## 0.10.0
+
+### Minor Changes
+
+- 9d7052c: Separate parameter values from local UI metadata, add strict parameter-document diagnostics and a generated JSON Schema, and rename the side-profile and contour APIs. Generator packages and modules now require format 3 and runtime 3.0.0.
+
+### Patch Changes
+
+- Updated dependencies [0eea1b4]
+- Updated dependencies [9d7052c]
+- Updated dependencies [cf597bd]
+  - @metamesh/generator-sdk@0.10.0
+  - @metamesh/modeling@0.10.0
+
+## 0.9.0
+
+### Patch Changes
+
+- Updated dependencies [e405876]
+- Updated dependencies [e405876]
+  - @metamesh/generator-sdk@0.9.0
+  - @metamesh/modeling@0.9.0
+
+## 0.8.0
+
+### Minor Changes
+
+- bf1abe4: Add circular baselines to prepared vector text and Generator text services. Shaped glyphs and attached marks rotate rigidly around a millimetre radius, preserving kerning, ligatures, exact curve bounds and logical advances. Circular text is limited to one line, baseline vertical alignment, less than one revolution, and outlines that stay clear of the circle's center axis.
+- bf1abe4: Complete solid splitting, plane clipping, Section hull/component/simplification operations, minimum-distance
+  queries and inspection facts. Add optional bounded geometric solid
+  validation at build/export boundaries and a pure uniform-density volume centroid helper.
+  Reuse immutable native inspection facts within a build and fresh owned topology analysis during
+  solid validation; share checks for identical buffer ranges without trusting mutable external facts.
+
+  Unify SVG default/preset limits and strict preset metadata checks. Preserve structured validation
+  codes and nested paths, add physical mesh assertions, and require runtime 2.1 for the current host
+  surface and issue metadata.
+
+### Patch Changes
+
+- Updated dependencies [bf1abe4]
+- Updated dependencies [bf1abe4]
+- Updated dependencies [bf1abe4]
+- Updated dependencies [bf1abe4]
+- Updated dependencies [bf1abe4]
+  - @metamesh/modeling@0.8.0
+  - @metamesh/generator-sdk@0.8.0
+
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies [b1b97b9]
+- Updated dependencies [b1b97b9]
+  - @metamesh/modeling@0.7.0
+  - @metamesh/generator-sdk@0.7.0
+
+## 0.6.0
+
+### Minor Changes
+
+- Run prepare/build through the shared Modeling engine. Remove direct native-kernel and generate bypass APIs; add direct preparation probes, finalized-model execution, and synchronous mesh assertions for an explicit engine.
+
+## 0.5.2
+
+### Patch Changes
+
+- Updated dependencies [02a1692]
+  - @metamesh/generator-sdk@0.5.2
+  - @metamesh/geometry@0.5.2
+
+## 0.5.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @metamesh/generator-sdk@0.5.1
+  - @metamesh/geometry@0.5.1
+
+## 0.5.0
+
+### Minor Changes
+
+- 0dc29c2: Add the portable numeric `curve-resolution` parameter role for model-owned physical curve
+  tolerance, with strict millimetre units, positive bounds, and one role per definition. Require
+  runtime 1.3.0 or later for packages declaring the role. Geometry and
+  Testkit follow the coordinated fixed Preview package release.
+
+### Patch Changes
+
+- Updated dependencies [0dc29c2]
+- Updated dependencies [0dc29c2]
+  - @metamesh/generator-sdk@0.5.0
+  - @metamesh/geometry@0.5.0
+
+## 0.4.0
+
+### Minor Changes
+
+- ad3bb49: Strengthen generator geometry with correct concave sweep caps, bounded region aggregation,
+  consistent finite input checks, protected copied-mesh scope exits, and shared primitive/extrusion
+  sampling. Add scoped hull, Minkowski sum, projection, slicing, and region revolution.
+
+  Compiled `MeshPart` now exposes `{ id, positions, indices, color? }`, directly compatible with SDK
+  `GeneratedPart`. Pass explicit `{ degrees }` or `{ radians }` to `rotationTransform3`, and rounded
+  rectangle sampling options as `{ segmentsPerCorner }` or `{ resolution }`.
+
+  Add `definePreparedGeneratorModule` for bounded, one-use validation/generation preparation while
+  preserving the five format-1 module exports. Authored `/v1` keeps its existing signatures and shares
+  the pure validation and sampling implementation with compiled modeling.
+
+### Patch Changes
+
+- Updated dependencies [ad3bb49]
+  - @metamesh/geometry@0.4.0
+  - @metamesh/generator-sdk@0.4.0
+
+## 0.3.0
+
+### Minor Changes
+
+- e87357e: Add direct catalog-font text geometry and matching metrics through prepared synchronous font
+  scopes. Share vector layout with SVG outlining, use natural font line spacing by default, and
+  make whitespace measurable. Nonzero tracking disables optional ligatures to match browser text.
+  Compiled Generators can receive font services during validation as well as generation; packages
+  declaring font parameters require runtime 1.2.0. Text geometry requires an exact font selection;
+  host text services expose shared vector layout. Browser editing uses prepared vector measurements.
+  Compiled module calls require explicit execution services for validation and generation.
+
+  Use the shared transform functions for both 2D sections and 3D solids. Reuse core-validated immutable
+  loops, polygons, and regions when winding and tolerance policies match, avoiding repeated topology
+  validation without changing tessellation or accepting unvalidated caller geometry.
+
+### Patch Changes
+
+- Updated dependencies [e87357e]
+  - @metamesh/geometry@0.3.0
+  - @metamesh/generator-sdk@0.3.0
+
+## 0.2.0
+
+### Minor Changes
+
+- 8b4e918: Add immutable font selections, font parameters and prepared text services, the optional Geometry
+  text engine, and reproducible font test services.
+
+### Patch Changes
+
+- Updated dependencies [8b4e918]
+  - @metamesh/generator-sdk@0.2.0
+  - @metamesh/geometry@0.2.0
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial public Preview release of the Generator contract assertions.

package/LICENSE

@@ -0,0 +1,200 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice.
+
+   Copyright 2026 MetaMesh
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,113 @@
-# Temporary Holding Version
+# `@metamesh/testkit`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Test MetaMesh models and Generators with the same generation engine used by their hosts. Check definitions,
+presets, mesh validity, and physical measurements with any test runner.
+
+> **Preview:** `0.x` minor releases may break compatibility. Patches remain compatible within the
+> same minor line.
+
+## Installation
+
+Install matching SDK, Modeling, and Testkit releases. Testkit is a development dependency:
+
+```bash
+pnpm add @metamesh/generator-sdk @metamesh/modeling
+pnpm add -D @metamesh/testkit
+```
+
+## Execute models in tests
+
+Given a Generator module exporting its `definition` and default runtime, such as the
+[SDK example](https://github.com/JasonKoolman/metamesh/blob/main/packages/generator-sdk/README.md#define-controls):
+
+```ts
+import { getDefaultParameters } from "@metamesh/generator-sdk/parameters";
+import { createGeneratorTestRunner, expectValidParts } from "@metamesh/testkit";
+
+import runtime, { definition } from "./generator.js";
+
+const runner = createGeneratorTestRunner(definition, runtime);
+try {
+  const result = await runner.execute(getDefaultParameters(definition));
+  if (result.type !== "generated") throw new Error("Expected valid Generator output.");
+  try {
+    await expectValidParts(result.model.parts);
+  } finally {
+    result.model.dispose();
+  }
+} finally {
+  runner.dispose();
+}
+```
+
+`execute` normalizes values, prepares services, and runs a persistent session. Schema and assertion
+errors return `invalid`; unexpected execution or malformed-output errors reject. Dispose returned
+snapshots separately from the runner; captured snapshots remain valid after runner disposal.
+
+Use `runner.validate(parameters, { normalize: false })` to probe deliberately invalid typed values
+without finalizing parts. It checks declarations and reached assertions; observing geometry can
+still initialize the engine. Creating a runner alone loads no engine or assets. Pass `options.engine`
+to reuse a test-owned engine and `options.limits` to lower host ceilings.
+
+## Assertions
+
+Helpers throw on failure without depending on your test framework:
+
+| Helper                         | Checks                                                             |
+| ------------------------------ | ------------------------------------------------------------------ |
+| `expectSerializableDefinition` | Strict parsing and a canonical JSON round trip                     |
+| `expectValidDefaults`          | Strict parameter decoding and agreement with definition defaults   |
+| `expectValidPresets`           | Serializable preset metadata; use the runner for domain assertions |
+| `expectValidParts`             | Strict part metadata, closed topology, and native reconstruction   |
+| `expectMeshMeasurements`       | Bounds, area, signed volume, and connected-component count         |
+
+`expectValidParts(parts, engine)` is synchronous and uses that engine's limits. Without an engine,
+it returns a promise using the shared test engine and default limits. It also accepts finalized
+parts, stripping measurement facts before strict validation; other unknown fields reject.
+
+Compare physical measurements with explicit tolerances. For a 30 × 20 × 4 mm box mesh:
+
+```ts
+import { expectMeshMeasurements } from "@metamesh/testkit";
+
+expectMeshMeasurements(
+  mesh,
+  { signedVolume: 30 * 20 * 4, connectedComponentCount: 1 },
+  { signedVolume: 0.05 }
+);
+```
+
+Bounds use mm, area mm², and volume mm³. Tolerances are absolute and default to zero; component
+counts are exact. Measurements check closed oriented topology without a native engine. Matching
+measurements alone do not establish geometric equivalence or exclude self-intersections; use
+`expectValidParts` for native reconstruction.
+
+## Font fixtures
+
+Supply `prepareServices` in runner options for models with fonts. It receives the definition and
+current parameters, and can return services synchronously or asynchronously. Missing fixtures or
+service failures reject before generation.
+
+`prepareFontTestServices` from `/fonts` checks immutable font revisions and prepares services from
+checked-in bytes. Install Modeling's optional `fontkit` peer, plus `woff2-encoder` for WOFF2 fixtures.
+Tests need no font downloads or browser cache; retain the fixtures' licenses.
+
+## Documentation
+
+Resolve `@metamesh/testkit/docs/manifest.json` for this installed version's Markdown
+reference and testing guidance. Testkit has no compiler, bundler, renderer, or browser dependencies.
+It shares the Modeling engine and Generator SDK contracts rather than duplicating runtime rules.
+
+For source checking, captured runs, documentation lookup, and images, install
+[`@metamesh/cli`](https://github.com/JasonKoolman/metamesh/blob/main/packages/cli/README.md).
+Its executable is `metamesh`; reusable Node authoring functions live in `@metamesh/cli/authoring`.
+
+- [Generator SDK](https://github.com/JasonKoolman/metamesh/blob/main/packages/generator-sdk/README.md) — definitions, parameter values, and module authoring.
+- [Modeling](https://github.com/JasonKoolman/metamesh/blob/main/packages/modeling/README.md) — geometry, sessions, and snapshots.
+- [API source](https://github.com/JasonKoolman/metamesh/blob/main/packages/testkit/src/index.ts) — runner and assertion exports; [font helpers](https://github.com/JasonKoolman/metamesh/blob/main/packages/testkit/src/fonts.ts) live in `/fonts`.
+
+For package development, see [Contributing](https://github.com/JasonKoolman/metamesh/blob/main/CONTRIBUTING.md).
+
+## License
+
+[Apache-2.0](https://github.com/JasonKoolman/metamesh/blob/main/packages/testkit/LICENSE).

package/dist/assertions.d.ts

@@ -0,0 +1,20 @@
+import type { GeneratorDefinition, GeneratorParams, GeneratorPreset } from "@metamesh/generator-sdk";
+import { type GeneratedPart } from "@metamesh/generator-sdk/runtime";
+import { type FinalizedPart } from "@metamesh/modeling";
+import type { ModelEngine } from "@metamesh/modeling/engine";
+/** Throws unless a definition already has the canonical package-serializable representation. */
+export declare function expectSerializableDefinition(definition: GeneratorDefinition): void;
+/** Throws unless defaults strictly decode and equal the defaults derived from the definition. */
+export declare function expectValidDefaults<const D extends GeneratorDefinition>(definition: D, defaults: GeneratorParams<D>): void;
+/** Checks preset metadata. Validate domain assertions through the generation test runner. */
+export declare function expectValidPresets<const D extends GeneratorDefinition>(definition: D, presets: readonly GeneratorPreset<D>[]): void;
+/**
+ * Checks finalized engine parts after omitting measurement facts from their strict wire DTOs.
+ * Runs mesh reconstruction/finalization synchronously using the supplied engine.
+ */
+export declare function expectValidParts(value: readonly FinalizedPart[], engine: ModelEngine): readonly GeneratedPart[];
+/** Strictly checks unknown wire data and reconstructs its meshes using the supplied engine. */
+export declare function expectValidParts(value: unknown, engine: ModelEngine): readonly GeneratedPart[];
+/** Initializes the shared test engine lazily, then applies the same wire and mesh checks. */
+export declare function expectValidParts(value: unknown): Promise<readonly GeneratedPart[]>;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,eAAe,EAChB,MAAM,yBAAyB,CAAC;AAMjC,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAC1F,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA4B7D,gGAAgG;AAChG,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,mBAAmB,GAAG,IAAI,CAUlF;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,CAAC,SAAS,mBAAmB,EACrE,UAAU,EAAE,CAAC,EACb,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAC3B,IAAI,CAQN;AAED,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,CAAC,SAAS,mBAAmB,EACpE,UAAU,EAAE,CAAC,EACb,OAAO,EAAE,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,GACrC,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,EAAE,WAAW,GAClB,SAAS,aAAa,EAAE,CAAC;AAE5B,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,aAAa,EAAE,CAAC;AAEhG,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC,CAAC"}

package/dist/assertions.js

@@ -0,0 +1,103 @@
+import { parseGeneratorDefinition, validateGeneratorPresets, } from "@metamesh/generator-sdk/packages";
+import { createParamCodec, getDefaultParameters } from "@metamesh/generator-sdk/parameters";
+import { parseGeneratedParts } from "@metamesh/generator-sdk/runtime";
+import { generate } from "@metamesh/modeling";
+import { getTestEngine } from "./engine.js";
+function stringify(value, label) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            throw new TypeError(`${label} is not JSON-serializable.`);
+        return serialized;
+    }
+    catch (cause) {
+        throw new TypeError(`${label} is not JSON-serializable.`, { cause });
+    }
+}
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, sortJson(entry)]));
+}
+function stableStringify(value, label) {
+    return stringify(sortJson(value), label);
+}
+/** Throws unless a definition already has the canonical package-serializable representation. */
+export function expectSerializableDefinition(definition) {
+    parseGeneratorDefinition(definition);
+    const decoded = JSON.parse(stringify(definition, "Generator definition"));
+    const parsed = parseGeneratorDefinition(decoded);
+    if (stableStringify(parsed, "Parsed Generator definition") !==
+        stableStringify(decoded, "Generator definition")) {
+        throw new TypeError("Generator definition must already use its canonical serialized form.");
+    }
+}
+/** Throws unless defaults strictly decode and equal the defaults derived from the definition. */
+export function expectValidDefaults(definition, defaults) {
+    const parsed = createParamCodec(definition).parse(defaults);
+    if (stableStringify(parsed, "Generator defaults") !==
+        stableStringify(getDefaultParameters(definition), "Derived Generator defaults")) {
+        throw new TypeError("Generator defaults do not match their definition.");
+    }
+}
+/** Checks preset metadata. Validate domain assertions through the generation test runner. */
+export function expectValidPresets(definition, presets) {
+    validateGeneratorPresets(definition, presets);
+}
+export function expectValidParts(value, engine) {
+    if (engine === undefined)
+        return getTestEngine().then((host) => expectValidParts(value, host));
+    const wireValue = Array.isArray(value)
+        ? value.map((part, index) => {
+            if (typeof part !== "object" || part === null || !Object.hasOwn(part, "measurements"))
+                return part;
+            const prototype = Object.getPrototypeOf(part);
+            if (prototype !== null && prototype !== Object.prototype)
+                return part;
+            const descriptors = Object.getOwnPropertyDescriptors(part);
+            if (Object.keys(descriptors).some((key) => ![
+                "id",
+                "positions",
+                "indices",
+                "color",
+                "measurements",
+                "geometry",
+                "position",
+                "rotation",
+            ].includes(key)))
+                return part;
+            // Captured engine snapshots expose owned buffer copies through accessors.
+            descriptors["positions"] = { value: part.positions, enumerable: true };
+            descriptors["indices"] = { value: part.indices, enumerable: true };
+            delete descriptors["position"];
+            delete descriptors["rotation"];
+            delete descriptors["measurements"];
+            delete descriptors["geometry"];
+            return Object.defineProperties({
+                geometryId: `assertion-${index}`,
+                geometryRevision: 0,
+                position: [0, 0, 0],
+                rotation: [0, 0, 0],
+            }, descriptors);
+        })
+        : value;
+    const parts = parseGeneratedParts(wireValue, engine.limits);
+    const session = engine.createSession(generate(({ part }) => parts.map((mesh) => part(mesh.id, {
+        geometry: mesh,
+        position: mesh.position,
+        rotation: mesh.rotation,
+        ...(mesh.color === undefined ? {} : { color: mesh.color }),
+    }))));
+    try {
+        session.run({}).dispose();
+    }
+    finally {
+        session.dispose();
+    }
+    return parts;
+}
+//# sourceMappingURL=assertions.js.map