Import and export

const mesh = output.mesh();

const binaryStl = output.export("stl");       // Uint8Array
const asciiStl = output.export("stl-ascii");  // string
const obj = output.export("obj");             // string

interface MeshData {
  positions: Float32Array; // xyz triples
  indices: Uint32Array;    // triangle vertex indices
}

const mesh = output.mesh({
  linearDeflection: 0.1,
  angularDeflection: 0.3,
  relative: false,
});

const step = output.export("step");
const brepText = output.export("brep");
const brepBinary = output.export("brep-binary");

const stepExport =
  inspectKernelStepExportCapabilities(kernel.capabilities);

const step = output.export("step", {
  metadata: {
    fileName: "mounting-plate.step",
    timestamp: "2026-07-26T12:00:00",
    productId: "PLATE-001",
    productName: "mounting-plate",
    productDescription: "Machined mounting plate",
  },
  signal,
  maxOutputBytes: 8 * 1024 * 1024,
});

import { writeFile } from "node:fs/promises";

await writeFile("part.stl", output.export("stl"));
await writeFile("part.step", output.export("step"));

const bytes = output.export("step");

return new Response(Uint8Array.from(bytes), {
  headers: {
    "Content-Type": "model/step",
    "Content-Disposition": 'attachment; filename="part.step"',
  },
});

const created = createImportedBodyDocument("verified-housing", {
  id: "housing",
  resource: {
    id: "housingStep",
    digest,
    byteLength: stepBytes.byteLength,
    mediaType: "model/step",
    locations: ["memory:housing.step"],
  },
  format: "step",
  units: { mode: "from-file" },
});
if (!created.ok) {
  throw new Error(created.diagnostics.map((item) => item.message).join("\n"));
}
const importedDocument = created.value;

const json = stringifyImportedBodyDocument(importedDocument);
const parsed = parseImportedBodyDocument(json, {
  limits: { maxDocumentBytes: 8 * 1024 * 1024 },
});

{
  "name": "verified-housing",
  "nodes": {
    "housing": {
      "expected": "single-solid",
      "format": "step",
      "healing": {
        "mode": "none"
      },
      "kind": "importedBody",
      "resource": "housingStep",
      "units": {
        "mode": "from-file"
      }
    }
  },
  "outputs": {
    "housing": {
      "kind": "solid",
      "node": "housing"
    }
  },
  "parameters": {},
  "resources": {
    "housingStep": {
      "byteLength": 18342,
      "digest": "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
      "locations": [
        "memory:housing.step"
      ],
      "mediaType": "model/step"
    }
  },
  "schema": "https://invariantcad.dev/schema/document/v7",
  "units": {
    "angle": "rad",
    "length": "mm"
  },
  "version": 7
}

const result = await evaluator.evaluateImportedBody(importedDocument, {
  resolver: async (request) => {
    // Resolve by your own policy, then return bytes. InvariantCAD verifies
    // request.digest and request.byteLength before native parsing.
    return loadCommittedBytes(request);
  },
  resourceLimits: { maxResourceBytes: 32 * 1024 * 1024 },
  signal,
});

import {
  EvaluatedSolid,
  createEvaluator,
  createImportedBodyDocument,
  design,
  mm,
  parseImportedBodyDocument,
  stringifyImportedBodyDocument,
  vec3,
  type CadResult,
  type ImportedBodyResourceDigest,
} from "invariantcad";

function valueOrThrow<T>(result: CadResult<T>): T {
  if (!result.ok) {
    throw new Error(
      result.diagnostics.map((item) => item.message).join("\n"),
    );
  }
  return result.value;
}

async function sha256(
  bytes: Uint8Array,
): Promise<ImportedBodyResourceDigest> {
  const digest = await crypto.subtle.digest(
    "SHA-256",
    Uint8Array.from(bytes),
  );
  const hexadecimal = Array.from(new Uint8Array(digest), (byte) =>
    byte.toString(16).padStart(2, "0"),
  ).join("");
  return `sha256:${hexadecimal}`;
}

const source = design("import-source");
const box = source.box("box", {
  size: vec3(mm(2), mm(3), mm(4)),
});
source.output("box", box);

async function runImportedBodyRoundTrip() {
  const evaluator = await createEvaluator({ profile: "mechanical-exact" });
  try {
    const sourceResult = valueOrThrow(
      await evaluator.evaluate(source.build()),
    );
    let sourceStep: Uint8Array;
    try {
      const output = sourceResult.output("box");
      if (!(output instanceof EvaluatedSolid)) {
        throw new Error("Expected the source output to be a solid");
      }
      sourceStep = output.export("step", {});
    } finally {
      sourceResult.dispose();
    }

    const digest = await sha256(sourceStep);
    const document = valueOrThrow(
      createImportedBodyDocument("verified-step-box", {
        id: "importedBox",
        resource: {
          id: "boxStep",
          digest,
          byteLength: sourceStep.byteLength,
          mediaType: "model/step",
          locations: ["memory:box.step"],
        },
        format: "step",
        units: { mode: "from-file" },
      }),
    );
    const canonicalJson = stringifyImportedBodyDocument(document);
    const reparsed = valueOrThrow(
      parseImportedBodyDocument(canonicalJson),
    );

    let resolverCalls = 0;
    const imported = valueOrThrow(
      await evaluator.evaluateImportedBody(reparsed, {
        resolver: (request) => {
          resolverCalls += 1;
          if (
            request.id !== "boxStep" ||
            request.digest !== digest ||
            request.byteLength !== sourceStep.byteLength ||
            request.mediaType !== "model/step"
          ) {
            throw new Error("Unexpected imported-body resource request");
          }
          return sourceStep;
        },
      }),
    );
    try {
      const measurements = imported.measure();
      const topology = valueOrThrow(imported.topology());
      const firstExport = imported.export("step", {});
      const secondExport = imported.export("step", {});

      return {
        canonicalRoundTrip:
          stringifyImportedBodyDocument(reparsed) === canonicalJson,
        resolverCalls,
        exact: imported.exact,
        representation: imported.representation,
        volume: measurements.volume,
        surfaceArea: measurements.surfaceArea,
        faces: topology.faces.length,
        exportedStepBytes: firstExport.byteLength,
        deterministicExport:
          firstExport.byteLength === secondExport.byteLength &&
          firstExport.every((byte, index) => byte === secondExport[index]),
      };
    } finally {
      imported.dispose();
    }
  } finally {
    evaluator.dispose();
  }
}

export const importedBodySummary = await runImportedBodyRoundTrip();
console.log(importedBodySummary);

const bytes = output.export("stl");
const blob = new Blob([Uint8Array.from(bytes)], { type: "model/stl" });
const url = URL.createObjectURL(blob);

try {
  const anchor = document.createElement("a");
  anchor.href = url;
  anchor.download = "part.stl";
  anchor.click();
} finally {
  URL.revokeObjectURL(url);
}

type DocumentV7ResourceScope =
  | { readonly source: "root" }
  | {
      readonly source: "external";
      readonly resource: ResourceId;
      readonly digest: ResourceDigestIR;
    };

import {
  inspectKernelDocumentBodyImportCapabilities,
  kernelSupportsDocumentBodyImport,
} from "invariantcad";
import { createOcctKernel } from "invariantcad/kernels/occt";

const kernel = await createOcctKernel();
try {
  const inspection = inspectKernelDocumentBodyImportCapabilities(
    kernel.capabilities,
  );
  if (
    inspection.status !== "valid" ||
    !kernelSupportsDocumentBodyImport(
      kernel.capabilities,
      "brep-binary",
      "declared",
    ) ||
    kernel.importDocumentBody === undefined
  ) {
    throw new Error("The selected kernel cannot import this document body");
  }

  const shape = kernel.importDocumentBody(brepBytes, {
    format: "brep-binary",
    units: { mode: "declared", length: "mm" },
    healing: { mode: "none" },
  });
  try {
    console.log(kernel.measure(shape).volume);
  } finally {
    kernel.disposeShape(shape);
  }
} finally {
  kernel.dispose();
}