pnpm add invariantcad

import {
  EvaluatedSolid,
  createEvaluator,
  design,
  mm,
  plane,
  vec2,
} from "invariantcad";
import { createOcctKernel } from "invariantcad/kernels/occt";

const cad = design("mounting-plate", {
  metadata: { description: "Parameterized plate with one mounting hole" },
});

const width = cad.parameter.length("width", mm(80), {
  min: mm(20),
  max: mm(200),
  description: "Overall plate width",
});
const height = cad.parameter.length("height", mm(50), { min: mm(10) });
const thickness = cad.parameter.length("thickness", mm(6), { min: mm(1) });
const holeRadius = cad.parameter.length("holeRadius", mm(4), { min: mm(1) });

const profile = cad.sketch("plate-profile", plane.xy(), (sketch) => {
  const outline = sketch.rectangle("outline", { width, height });
  const hole = sketch.circle("hole", {
    center: vec2(width.mul(0.25), mm(0)),
    radius: holeRadius,
  });
  return sketch.profile(outline, { holes: [hole.loop()] });
});

const solid = cad.extrude("plate-solid", profile, {
  distance: thickness,
  symmetric: true,
});
const part = cad.part("plate", solid, {
  partNumber: "PLATE-001",
  description: "Machined mounting plate",
});
cad.output("plate", part);

const document = cad.build();
const parameters = {
  width: 100,
  holeRadius: 5,
};

async function evaluateDefaultMesh() {
  const evaluator = await createEvaluator();
  try {
    const result = await evaluator.evaluate(document, {
      parameters,
      outputs: ["plate"],
    });
    if (!result.ok) {
      throw new Error(
        result.diagnostics.map((item) => item.message).join("\n"),
      );
    }

    try {
      const plate = result.value.output("plate");
      if (!(plate instanceof EvaluatedSolid)) {
        throw new Error("Expected the 'plate' output to be a solid part");
      }
      return {
        volume: plate.measure().volume,
        stl: plate.export("stl"),
      };
    } finally {
      result.value.dispose();
    }
  } finally {
    evaluator.dispose();
  }
}

async function exportExactStep() {
  const kernel = await createOcctKernel();
  let evaluatorOwnsKernel = false;
  try {
    const evaluator = await createEvaluator({ kernel });
    evaluatorOwnsKernel = true;
    try {
      const result = await evaluator.evaluate(document, {
        parameters,
        outputs: ["plate"],
      });
      if (!result.ok) {
        throw new Error(
          result.diagnostics.map((item) => item.message).join("\n"),
        );
      }

      try {
        const plate = result.value.output("plate");
        if (!(plate instanceof EvaluatedSolid)) {
          throw new Error("Expected the 'plate' output to be a solid part");
        }
        return {
          volume: plate.measure().volume,
          step: plate.export("step"),
        };
      } finally {
        result.value.dispose();
      }
    } finally {
      evaluator.dispose();
    }
  } finally {
    // A rejected caller-supplied kernel remains caller-owned.
    if (!evaluatorOwnsKernel) kernel.dispose();
  }
}

const defaultMesh = await evaluateDefaultMesh();
const exact = await exportExactStep();

export const mountingPlateSummary = {
  defaultVolume: defaultMesh.volume,
  defaultStlBytes: defaultMesh.stl.byteLength,
  exactVolume: exact.volume,
  stepBytes: exact.step.byteLength,
  stepHeader: new TextDecoder().decode(exact.step.subarray(0, 32)),
};
console.log(mountingPlateSummary);

const section = cad.sketch("section", plane.yz(), (sketch) =>
  sketch.profile(
    sketch.rectangle("outline", { width: mm(2), height: mm(2) }),
  ),
);
const spine = cad.polylinePath("spine", [
  vec3(mm(0), mm(0), mm(0)),
  vec3(mm(5), mm(0), mm(0)),
  vec3(mm(5), mm(5), mm(0)),
]);
const swept = cad.sweep("swept", section, spine);

const bend = cad.circularArcPath("bend", {
  start: vec3(mm(0), mm(0), mm(0)),
  through: vec3(
    mm(10 / Math.sqrt(2)),
    mm(10 - 10 / Math.sqrt(2)),
    mm(0),
  ),
  end: vec3(mm(10), mm(10), mm(0)),
});
const curved = cad.sweep("curved", section, bend);

const route = cad.compositePath("route", {
  start: vec3(mm(0), mm(0), mm(0)),
  segments: [
    { kind: "line", end: vec3(mm(5), mm(0), mm(0)) },
    {
      kind: "circularArc",
      through: vec3(mm(5 + 5 / Math.sqrt(2)), mm(5 - 5 / Math.sqrt(2)), mm(0)),
      end: vec3(mm(10), mm(5), mm(0)),
    },
    { kind: "line", end: vec3(mm(10), mm(10), mm(0)) },
  ],
});
const routed = cad.sweep("routed", section, route);

import {
  angleVec3,
  deg,
  design,
  explainTopologySelection,
  mm,
  plane,
  scalarVec3,
  tf,
  topology,
  vec3,
} from "invariantcad";

const cad = design("source-stable-fillet");
const width = cad.parameter.length("width", mm(40));
const height = cad.parameter.length("height", mm(20));
const profile = cad.sketch("profile", plane.xy(), (sketch) =>
  sketch.profile(
    sketch.rectangle("outline", { width, height }),
  ),
);
const extrusion = cad.extrude("extrusion", profile, {
  distance: mm(10),
});
const moved = cad.transform("moved", extrusion, [
  tf.rotate(angleVec3(deg(0), deg(0), deg(90))),
  tf.translate(vec3(mm(100), mm(5), mm(7))),
]);

const rightEndRim = topology.edges
  .createdBy(extrusion, {
    role: "extrude.edge.end-rim",
    source: { sketch: profile, entity: "outline.e1" },
  })
  .and(topology.edges.modifiedBy(moved))
  .select(); // exactly one edge

const rounded = cad.fillet("rounded", moved, {
  edges: rightEndRim,
  radius: mm(2),
});
cad.output("rounded", rounded);

const beveled = cad.chamfer("beveled", moved, {
  edges: rightEndRim,
  distance: mm(2),
});
cad.output("beveled", beveled);

const openEnd = topology.faces
  .createdBy(extrusion, { role: "extrude.face.end-cap" })
  .and(topology.faces.modifiedBy(moved))
  .select();

const hollow = cad.shell("hollow", moved, {
  openings: openEnd,
  thickness: mm(2),
  direction: "inward",
  tolerance: mm(1e-6),
});
cad.output("hollow", hollow);

const expanded = cad.offset("expanded", moved, {
  distance: mm(1),
  direction: "outward",
  tolerance: mm(1e-6),
});
cad.output("expanded", expanded);

const draftedSide = topology.faces
  .createdBy(extrusion, {
    role: "extrude.face.side",
    source: { sketch: profile, entity: "outline.e1" },
  })
  .and(topology.faces.modifiedBy(moved))
  .select();

const drafted = cad.draft("drafted", moved, {
  faces: draftedSide,
  angle: deg(3),
  pullDirection: scalarVec3(0, 0, 1),
  neutralPlane: {
    origin: vec3(mm(100), mm(5), mm(7)),
    normal: scalarVec3(0, 0, 1),
  },
});
cad.output("drafted", drafted);

// Given a live evaluated solid from a topology-capable kernel:
const current = evaluatedSolid.topology();
if (!current.ok) throw new Error(current.diagnostics[0]?.message);

const selection = topology.faces.all().exactly(1);
const explainedSelection = explainTopologySelection(
  selection.ir,
  current.value,
  {
    // This `all` query contains no expressions, so evaluation is never called.
    evaluate: () => {
      throw new Error("Unexpected selector expression");
    },
  },
);
if (!explainedSelection.ok) {
  throw new Error(explainedSelection.diagnostics[0]?.message);
}

switch (explainedSelection.value.outcome) {
  case "resolved":
    console.log(explainedSelection.value.keys);
    break;
  case "missing":
  case "ambiguous":
    console.log(explainedSelection.value.candidatesMatched);
    break;
}

{
  protocolVersion: 2,
  fingerprint: "kernel-specific descriptor compatibility declaration",
}

const signatures = kernel.capabilities.topology?.signatures;
const signatureLimits = { maxTopologyItems: 50_000 };
const firstTopology = firstOutput.topology();
if (signatures === undefined || !firstTopology.ok) {
  throw new Error("This evaluation cannot capture persistent topology");
}

const face = firstTopology.value.faces.find((item) =>
  item.lineage.some((entry) => entry.role === "box.face.x-min"),
);
if (face === undefined) throw new Error("Expected box face was not present");

const reference = captureTopologyReference(
  firstTopology.value,
  "face",
  face.key,
  {
    capabilities: signatures,
    tolerance: { linear: 1e-6, angular: 1e-9, relative: 1e-9 },
    limits: signatureLimits,
  },
);
if (!reference.ok) throw new Error(reference.diagnostics[0]?.message);

// Re-author the stable target node and store the captured design intent.
const nextCad = design("persistent-shell");
const nextBox = nextCad.box("box", {
  size: vec3(mm(12), mm(20), mm(30)),
});
const openingFace = nextCad.topologyReference("opening-face", nextBox, {
  topology: "face",
  variants: [reference.value],
});
const hollow = nextCad.shell("hollow", nextBox, {
  openings: topology.faces.persistentReference(openingFace).select(),
  thickness: mm(1),
});
nextCad.output("hollow", hollow);

// Or resolve the detached evidence directly against a later snapshot:
const nextTopology = nextOutput.topology();
// If nextOutput came from another kernel instance, read that instance instead.
const nextSignatures = kernel.capabilities.topology?.signatures;
if (!nextTopology.ok || nextSignatures === undefined) {
  throw new Error("The later evaluation cannot resolve persistent topology");
}
const resolved = resolveTopologyReference(reference.value, nextTopology.value, {
  // Always use the declaration from the kernel that produced nextTopology.
  capabilities: nextSignatures,
  limits: signatureLimits,
});

const explained = explainTopologyReference(
  reference.value,
  nextTopology.value,
  { capabilities: nextSignatures, limits: signatureLimits },
);
if (!explained.ok) throw new Error(explained.diagnostics[0]?.message);
if (explained.value.outcome === "resolved") {
  console.log(explained.value.key, explained.value.evidence);
} else {
  console.log(explained.value.outcome, explained.value.candidatesMatched);
}

integral(((r dot r) I - r r^T) dV)

import {
  momentOfInertiaAboutAxis,
  principalInertia,
  principalRadiiOfGyration,
  worldRadiiOfGyration,
} from "invariantcad";

const measured = output.measure();
const principal = principalInertia(measured.inertiaTensor);
// principal.moments is ascending; principal.axes[i] matches moments[i].
console.log(principal.degeneracy, principal.moments, principal.axes);
console.log(worldRadiiOfGyration(measured));
console.log(principalRadiiOfGyration(measured));
console.log(
  momentOfInertiaAboutAxis(measured, {
    point: [0, 0, 0],
    direction: [0, 0, 1],
  }),
);

import { EvaluatedPart, kgPerCubicMeter } from "invariantcad";

const density = cad.parameter.massDensity(
  "density",
  kgPerCubicMeter(2700),
);
const aluminum = cad.material("aluminum-6061-t6", {
  name: "6061-T6 Aluminum",
  massDensity: density,
});
const part = cad.part("bracket", solid, {
  partNumber: "BRACKET-001",
  materialRef: aluminum,
});
cad.output("bracket", part);

const evaluated = await evaluator.evaluate(cad.build(), {
  // Parameter overrides use the document base unit, here kg/mm^3.
  parameters: { density: 7.85e-6 },
});
if (evaluated.ok) {
  try {
    const output = evaluated.value.output("bracket");
    if (output instanceof EvaluatedPart) {
      const properties = output.physicalMassProperties();
      if (properties.ok) console.log(properties.value.mass);
    }
  } finally {
    evaluated.value.dispose();
  }
}

import { tf, vec3, mm } from "invariantcad";

const product = cad.assembly("product", (assembly) => {
  assembly.instance("left", part);
  assembly.instance("right", part, {
    placement: [tf.translate(vec3(mm(100), mm(0), mm(0)))],
  });
});

cad.output("product", product);

import { EvaluatedAssembly } from "invariantcad";

const evaluated = await evaluator.evaluate(cad.build(), {
  outputs: ["product"],
});
if (evaluated.ok) {
  try {
    const output = evaluated.value.output("product");
    if (output instanceof EvaluatedAssembly) {
      const bom = output.billOfMaterials();
      if (!bom.ok) {
        console.error(bom.diagnostics);
      } else {
        console.table(bom.value.items);
        console.log({
          quantity: bom.value.totalQuantity,
          massComplete: bom.value.massComplete,
          knownMass: bom.value.knownMass,
          totalMass: bom.value.totalMass,
        });
        // Successful partial BOMs can still carry warning diagnostics.
        console.warn(bom.diagnostics);
      }
    }
  } finally {
    evaluated.value.dispose();
  }
}

const compactSingle = cad.configuration(
  "compact-single",
  (configuration) => {
    configuration.parameter(width, mm(60));
    configuration.instanceSuppressed(product, "right");
    configuration.partMaterial(part, steel);
  },
  { description: "One compact bracket in steel" },
);

const evaluated = await evaluator.evaluate(cad.build(), {
  configuration: compactSingle,
  parameters: {
    width: 72, // Call-time values override the selected configuration.
  },
});

if (evaluated.ok) {
  try {
    console.log(evaluated.value.configurationId); // "compact-single"
    const output = evaluated.value.output("product");
    if (output instanceof EvaluatedAssembly) {
      const bom = output.billOfMaterials();
      if (bom.ok) console.log(bom.value.configurationId);
    }
  } finally {
    evaluated.value.dispose();
  }
}

import {
  hashDocument,
  parseDocument,
  stringifyDocument,
} from "invariantcad";

const json = stringifyDocument(document, { pretty: true });
const parsed = parseDocument(json);
const semanticHash = await hashDocument(document);

import {
  DESIGN_IMPACT_REPORT_VERSION,
  analyzeDesignImpact,
} from "invariantcad";

const impact = analyzeDesignImpact(document, {
  parameters: [width.id],
});

if (impact.ok) {
  console.log(impact.value.version === DESIGN_IMPACT_REPORT_VERSION); // true
  console.log(impact.value.nodes);
  console.log(impact.value.outputs);
}

import {
  FEATURE_HASH_PROTOCOL_VERSION,
  hashDesignFeatures,
} from "invariantcad";

const hashes = await hashDesignFeatures(document, {
  configuration: "compact-single",
  parameters: { width: 72 },
});

if (hashes.ok) {
  console.log(hashes.value.hashProtocolVersion === FEATURE_HASH_PROTOCOL_VERSION);
  console.log(hashes.value.nodes);
  console.log(hashes.value.outputs);
}

if (!result.ok) {
  for (const issue of result.diagnostics) {
    console.error(issue.code, issue.path, issue.message);
  }
}

invariantcad validate design.invariantcad.json
invariantcad inspect design.invariantcad.json
invariantcad inspect design.invariantcad.json --parameters dimensions.json
invariantcad inspect design.invariantcad.json --parameter width=120 --parameter=height=80
invariantcad inspect design.invariantcad.json --configuration compact-single
invariantcad inspect design.invariantcad.json --output plate
invariantcad bom design.invariantcad.json --output product
invariantcad bom design.invariantcad.json --output product --configuration compact-single
invariantcad export design.invariantcad.json --output plate --to plate.stl
invariantcad export design.invariantcad.json --output product --configuration compact-single --to product.stl
invariantcad export design.invariantcad.json --output plate --format obj --to plate.obj
invariantcad export design.invariantcad.json --output plate --to plate.step
invariantcad inspect design.invariantcad.json --kernel occt

import { createEvaluator } from "invariantcad";
import { createOcctKernel } from "invariantcad/kernels/occt";

const manifoldEvaluator = await createEvaluator();
const occtKernel = await createOcctKernel();

import { createEvaluator } from "invariantcad";

const evaluator = await createEvaluator({
  manifold: { wasmUrl: "/wasm/manifold.wasm" },
});

import occtWasmUrl from "occt-wasm/dist/occt-wasm.wasm?url";
import { createOcctKernel } from "invariantcad/kernels/occt";

const kernel = await createOcctKernel({ wasm: occtWasmUrl });

import { createOcctKernel } from "invariantcad/kernels/occt";
import {
  INVARIANTCAD_OCCT_FACADE_0_9_0_RELEASE_MANIFEST_SHA256,
  loadAttestedOcctRuntime,
} from "invariantcad/kernels/occt/browser";

const attestedRuntime = await loadAttestedOcctRuntime({
  releaseManifest,
  expectedReleaseManifestSha256:
    INVARIANTCAD_OCCT_FACADE_0_9_0_RELEASE_MANIFEST_SHA256,
  javascript,
  webassembly,
});
const kernel = await createOcctKernel({ attestedRuntime });

Content-Security-Policy: script-src 'self' blob: 'wasm-unsafe-eval' 'unsafe-eval'

import ownedOcctModuleFactory from "./occt-facade/occt-wasm.js";
import ownedOcctWasmUrl from "./occt-facade/occt-wasm.wasm?url";
import { createOcctKernel } from "invariantcad/kernels/occt";

const kernel = await createOcctKernel({
  moduleFactory: ownedOcctModuleFactory,
  wasm: ownedOcctWasmUrl,
  maxExactBooleanHistoryRecords: 1_000_000,
  maxExactEdgeTreatmentHistoryRecords: 1_000_000,
  maxExactSolidOffsetHistoryRecords: 1_000_000,
});

pnpm build:occt-facade
pnpm bundle:occt-facade
pnpm verify:occt-facade-bundle
pnpm test:occt-facade-bundle

TypeScript builders
        │
        ▼
immutable DesignDocument v6 ──► validation / canonical JSON / hashing
  (v1/v2/v3/v4/v5 stay frozen, readable, directly evaluable, and migratable)
        │
        ├──► sketch-solver protocol ──► reference solver (v0.1)
        │
        └──► geometry-kernel protocol ──► Manifold mesh kernel
                                      └─► exact OCCT B-Rep kernel
        │
        ▼
evaluated parts / assemblies ──► measurement / mesh / STL / OBJ / STEP / BREP

pnpm install
pnpm check
pnpm test
pnpm build
pnpm example:bracket
pnpm verify

# Heavyweight owned-facade release checks (after building the facade)
pnpm test:occt-persistence-public
pnpm test:occt-facade-bundle