@ifc-lite/codegen 1.15.3 → 1.15.5

package/README.md

@@ -14,19 +14,25 @@ npm install --save-dev @ifc-lite/codegen
 
 ```bash
 # IFC4 (776 entities)
-npx ifc-lite-codegen ./schemas/IFC4.exp --out ./src/generated
+node dist/cli.js schemas/IFC4_ADD2_TC1.exp --output ./generated/ifc4
 
 # IFC4X3 (876 entities, includes infrastructure: roads, bridges, alignments)
-npx ifc-lite-codegen ./schemas/IFC4X3.exp --out ./src/generated
+node dist/cli.js schemas/IFC4X3.exp --output ./generated/ifc4x3
 ```
 
-Generated files (one per output directory):
+Pass `--rust` to also emit Rust type tables (consumed by the ifc-lite Rust core).
 
-```
-src/generated/
+Generated files (one per output directory, e.g. `./generated/ifc4`):
+
+```text
+generated/ifc4/
 ├── entities.ts          ← TypeScript interfaces for every entity
+├── types.ts             ← defined-type aliases
+├── enums.ts             ← enum definitions
+├── selects.ts           ← SELECT union types
 ├── schema-registry.ts   ← runtime metadata (parent, attributes, ...)
-├── types.ts             ← enum unions and SELECT types
+├── type-ids.ts          ← numeric type-id lookup tables
+├── serializers.ts       ← STEP serializer bound to the schema registry
 └── index.ts             ← barrel export
 ```
 
@@ -34,19 +40,16 @@ src/generated/
 
 ```typescript
 import { parseExpressSchema, generateTypeScript } from '@ifc-lite/codegen';
-import { writeFile } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 
-const schema = parseExpressSchema('./schemas/IFC4.exp');
+const schema = parseExpressSchema(await readFile('./schemas/IFC4.exp', 'utf-8'));
 
 console.log(`Parsed ${schema.entities.length} entities, ${schema.types.length} types`);
 
-const generated = generateTypeScript(schema, {
-  inheritanceChain: true,
-  emitEnums: true,
-});
+const generated = generateTypeScript(schema);
 
-await writeFile('./src/generated/entities.ts', generated.entities);
-await writeFile('./src/generated/schema-registry.ts', generated.schemaRegistry);
+await writeFile('./generated/ifc4/entities.ts', generated.entities);
+await writeFile('./generated/ifc4/schema-registry.ts', generated.schemaRegistry);
 ```
 
 ## What you get

package/dist/serialization-generator.d.ts

@@ -1,11 +1,16 @@
 /**
  * Serialization Generator
  *
- * Generates TypeScript code for serializing IFC entities to STEP format.
+ * Emits the per-schema STEP serializer bundle file. The serialization LOGIC is
+ * schema-agnostic and lives once in `@ifc-lite/data`; this generator emits only
+ * a thin binding that re-exports those primitives and binds the bundle's
+ * `SCHEMA_REGISTRY` to the registry-coupled helpers. Keeping the logic in a
+ * single place means the generated copies can never drift from the runtime.
  */
 import type { ExpressSchema } from './express-parser.js';
 /**
- * Generate serialization support code
+ * Generate serialization support code — a thin re-export of the shared
+ * `@ifc-lite/data` STEP serializer with this schema's registry bound in.
  */
 export declare function generateSerializers(schema: ExpressSchema): string;
 //# sourceMappingURL=serialization-generator.d.ts.map

package/dist/serialization-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization-generator.d.ts","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAyC,MAAM,qBAAqB,CAAC;AAGhG;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAsUjE"}
+{"version":3,"file":"serialization-generator.d.ts","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAqDjE"}

package/dist/serialization-generator.js

@@ -2,10 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 /**
- * Generate serialization support code
+ * Generate serialization support code — a thin re-export of the shared
+ * `@ifc-lite/data` STEP serializer with this schema's registry bound in.
  */
 export function generateSerializers(schema) {
-    let code = `/* This Source Code Form is subject to the terms of the Mozilla Public
+    return `/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
@@ -13,321 +14,49 @@ export function generateSerializers(schema) {
  * IFC Serialization Support
  * Generated from EXPRESS schema: ${schema.name}
  *
- * Utilities for serializing IFC entities to STEP format.
+ * Thin binding over the shared, schema-agnostic STEP serializer in
+ * \`@ifc-lite/data\`. All serialization logic lives there (single source of
+ * truth); only this bundle's \`SCHEMA_REGISTRY\` is bound to the registry-coupled
+ * helpers below.
  *
  * DO NOT EDIT - This file is auto-generated
  */
 
 import { SCHEMA_REGISTRY } from './schema-registry.js';
-
-/**
- * STEP value types
- */
-export type StepValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | StepValue[]
-  | EntityRef
-  | EnumValue;
-
-/**
- * Entity reference (#123)
- */
-export interface EntityRef {
-  ref: number;
-}
-
-/**
- * Enum value (.VALUE.)
- */
-export interface EnumValue {
-  enum: string;
-}
-
-/**
- * Check if value is an entity reference
- */
-export function isEntityRef(value: unknown): value is EntityRef {
-  return typeof value === 'object' && value !== null && 'ref' in value;
-}
-
-/**
- * Check if value is an enum value
- */
-export function isEnumValue(value: unknown): value is EnumValue {
-  return typeof value === 'object' && value !== null && 'enum' in value;
-}
-
-/**
- * Create an entity reference
- */
-export function ref(id: number): EntityRef {
-  return { ref: id };
-}
-
-/**
- * Create an enum value
- */
-export function enumVal(value: string): EnumValue {
-  return { enum: value };
-}
-
-/**
- * Base interface for serializable entities
- */
-export interface StepEntity {
-  /** Express ID (#123) */
-  expressId: number;
-  /** IFC type name */
-  type: string;
-  /** Attribute values */
-  [key: string]: unknown;
-}
-
-/**
- * Serialize a single value to STEP format
- */
-export function serializeValue(value: StepValue): string {
-  // Null/undefined -> $
-  if (value === null || value === undefined) {
-    return '$';
-  }
-
-  // Derived value -> *
-  if (value === '*') {
-    return '*';
-  }
-
-  // Boolean
-  if (typeof value === 'boolean') {
-    return value ? '.T.' : '.F.';
-  }
-
-  // Number
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) {
-      return '$';
-    }
-    // Use exponential notation for large/small numbers
-    if (Math.abs(value) > 1e10 || (Math.abs(value) < 1e-10 && value !== 0)) {
-      return value.toExponential(10).toUpperCase().replace('E+', 'E');
-    }
-    // Otherwise use fixed notation
-    const str = value.toString();
-    // Ensure there's a decimal point for REAL values
-    return str.includes('.') ? str : str + '.';
-  }
-
-  // String
-  if (typeof value === 'string') {
-    return "'" + escapeStepString(value) + "'";
-  }
-
-  // Entity reference
-  if (isEntityRef(value)) {
-    return '#' + value.ref;
-  }
-
-  // Enum value
-  if (isEnumValue(value)) {
-    return '.' + value.enum + '.';
-  }
-
-  // Array/List
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return '()';
-    }
-    return '(' + value.map(v => serializeValue(v as StepValue)).join(',') + ')';
-  }
-
-  // Object (shouldn't happen for valid STEP values)
-  return '$';
-}
-
-/**
- * Escape a string for STEP format
- */
-function escapeStepString(str: string): string {
-  return str
-    .replace(/\\\\/g, '\\\\\\\\')  // Backslash
-    .replace(/'/g, "''");           // Single quote
-}
-
-/**
- * Serialize an entity to a STEP line
+import {
+  generateHeader,
+  generateStepFileWithRegistry,
+  toStepLineWithRegistry,
+  type StepEntity,
+} from '@ifc-lite/data';
+
+export {
+  isEntityRef,
+  isEnumValue,
+  ref,
+  enumVal,
+  serializeValue,
+  generateHeader,
+  parseStepValue,
+} from '@ifc-lite/data';
+export type { StepValue, EntityRef, EnumValue, StepEntity } from '@ifc-lite/data';
+
+/**
+ * Serialize an entity to a STEP line (bound to this bundle's schema).
  */
 export function toStepLine(entity: StepEntity): string {
-  const schema = SCHEMA_REGISTRY.entities[entity.type];
-  if (!schema) {
-    throw new Error(\`Unknown entity type: \${entity.type}\`);
-  }
-
-  // Get all attributes in order
-  const values: string[] = [];
-  for (const attr of schema.allAttributes) {
-    const value = entity[attr.name];
-    values.push(serializeValue(value as StepValue));
-  }
-
-  return \`#\${entity.expressId}=\${entity.type.toUpperCase()}(\${values.join(',')});\`;
+  return toStepLineWithRegistry(SCHEMA_REGISTRY, entity);
 }
 
 /**
- * Generate STEP file header
- */
-export function generateHeader(options: {
-  description?: string;
-  author?: string;
-  organization?: string;
-  application?: string;
-  schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
-  filename?: string;
-}): string {
-  const now = new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
-  const desc = options.description || 'ViewDefinition [CoordinationView]';
-  const author = options.author || '';
-  const org = options.organization || '';
-  const app = options.application || 'ifc-lite';
-  const filename = options.filename || 'output.ifc';
-
-  return \`ISO-10303-21;
-HEADER;
-FILE_DESCRIPTION('\${desc}','2;1');
-FILE_NAME('\${filename}','\${now}',('\${author}'),('\${org}'),'\${app}','\${app}','');
-FILE_SCHEMA(('\${options.schema}'));
-ENDSEC;
-\`;
-}
-
-/**
- * Generate complete STEP file content
+ * Generate complete STEP file content (bound to this bundle's schema).
  */
 export function generateStepFile(
   entities: StepEntity[],
   options: Parameters<typeof generateHeader>[0]
 ): string {
-  const header = generateHeader(options);
-
-  // Sort entities by ID for deterministic output
-  const sorted = [...entities].sort((a, b) => a.expressId - b.expressId);
-
-  const data = sorted.map(e => toStepLine(e)).join('\\n');
-
-  return \`\${header}DATA;
-\${data}
-ENDSEC;
-END-ISO-10303-21;
-\`;
-}
-
-/**
- * Parse a STEP value from string
- */
-export function parseStepValue(str: string): StepValue {
-  str = str.trim();
-
-  // Null
-  if (str === '$') {
-    return null;
-  }
-
-  // Derived
-  if (str === '*') {
-    return '*' as unknown as StepValue;
-  }
-
-  // Boolean
-  if (str === '.T.') {
-    return true;
-  }
-  if (str === '.F.') {
-    return false;
-  }
-  if (str === '.U.') {
-    return null; // Unknown/indeterminate
-  }
-
-  // Entity reference
-  if (str.startsWith('#')) {
-    return { ref: parseInt(str.substring(1), 10) };
-  }
-
-  // Enum
-  if (str.startsWith('.') && str.endsWith('.')) {
-    return { enum: str.substring(1, str.length - 1) };
-  }
-
-  // String
-  if (str.startsWith("'") && str.endsWith("'")) {
-    return unescapeStepString(str.substring(1, str.length - 1));
-  }
-
-  // List
-  if (str.startsWith('(') && str.endsWith(')')) {
-    return parseStepList(str);
-  }
-
-  // Number
-  const num = parseFloat(str);
-  if (!isNaN(num)) {
-    return num;
-  }
-
-  // Unknown
-  return str;
-}
-
-/**
- * Parse a STEP list
- */
-function parseStepList(str: string): StepValue[] {
-  // Remove outer parentheses
-  const inner = str.substring(1, str.length - 1).trim();
-  if (inner === '') {
-    return [];
-  }
-
-  const values: StepValue[] = [];
-  let depth = 0;
-  let current = '';
-
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i];
-
-    if (char === '(' || char === '[') {
-      depth++;
-      current += char;
-    } else if (char === ')' || char === ']') {
-      depth--;
-      current += char;
-    } else if (char === ',' && depth === 0) {
-      values.push(parseStepValue(current));
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-
-  if (current.trim()) {
-    values.push(parseStepValue(current));
-  }
-
-  return values;
-}
-
-/**
- * Unescape a STEP string
- */
-function unescapeStepString(str: string): string {
-  return str
-    .replace(/''/g, "'")
-    .replace(/\\\\\\\\/g, '\\\\');
+  return generateStepFileWithRegistry(SCHEMA_REGISTRY, entities, options);
 }
 `;
-    return code;
 }
 //# sourceMappingURL=serialization-generator.js.map

package/dist/serialization-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"serialization-generator.js","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAW/D;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,IAAI,IAAI,GAAG;;;;;;oCAMuB,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4T9C,CAAC;IAEA,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"serialization-generator.js","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAc/D;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,OAAO;;;;;;oCAM2B,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C9C,CAAC;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/codegen",
-  "version": "1.15.3",
+  "version": "1.15.5",
   "description": "TypeScript code generator from IFC EXPRESS schemas",
   "type": "module",
   "repository": {
@@ -16,22 +16,33 @@
     "codegen",
     "typescript"
   ],
-  "author": "",
-  "license": "MIT",
+  "author": "Louis True",
+  "license": "MPL-2.0",
   "dependencies": {
-    "commander": "^15.0.0"
+    "commander": "^15.0.0",
+    "@ifc-lite/data": "^2.5.1"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
+    "@types/node": "^26.1.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.0"
+    "vitest": "^4.1.9"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://ltplus-ag.github.io/ifc-lite/",
+  "bugs": "https://github.com/LTplus-AG/ifc-lite/issues",
+  "files": [
+    "dist",
+    "schemas",
+    "README.md"
+  ],
   "scripts": {
     "build": "pnpm exec tsc",
     "dev": "pnpm exec tsc --watch",
     "test": "vitest run",
     "generate": "node dist/cli.js",
-    "generate:ifc4": "node dist/cli.js schemas/IFC4.exp -o generated/ifc4",
+    "generate:ifc4": "node dist/cli.js schemas/IFC4_ADD2_TC1.exp -o generated/ifc4",
     "generate:ifc4x3": "node dist/cli.js schemas/IFC4X3.exp -o generated/ifc4x3"
   }
 }

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @ifc-lite/codegen@1.15.3 build /home/runner/work/ifc-lite/ifc-lite/packages/codegen
-> pnpm exec tsc
-

package/CHANGELOG.md

@@ -1,117 +0,0 @@
-# @ifc-lite/codegen
-
-## 1.15.3
-
-### Patch Changes
-
-- [#946](https://github.com/LTplus-AG/ifc-lite/pull/946) [`6378998`](https://github.com/LTplus-AG/ifc-lite/commit/6378998ec146f7f9297ef5fcc5953b155fd6b5e0) Thanks [@louistrue](https://github.com/louistrue)! - Fix a batch of verified findings from a full-codebase review (security, correctness,
-  data-loss, and resource/memory leaks). Highlights:
-
-  **Security**
-
-  - collab-server: a malformed WebSocket frame no longer crashes the whole process
-    (decode is wrapped; a bad frame is rejected/audited instead of throwing).
-  - mcp: the local HTTP transport now validates `Host`/`Origin` and no longer sends a
-    wildcard `Access-Control-Allow-Origin`, closing a DNS-rebinding/CSRF hole; the
-    `AuthScope.modelIds` allowlist is now enforced at model resolution.
-  - server-bin: `extractZip` uses `execFileSync` (argv, no shell), removing command
-    injection via archive/destination paths.
-  - export / sdk / cli / mcp / lists / viewer CSV exporters now neutralize spreadsheet
-    formula injection (CWE-1236) consistently.
-  - create-ifc-lite: validates the project name (no path traversal) and drops the
-    unused `execSync`-based downloader.
-  - embed-sdk: inbound `postMessage` now validates `event.origin`.
-
-  **Correctness / data-loss**
-
-  - parser: `lengthUnitScale` survives the worker transport; the nested STEP list
-    parser is string-aware (commas/parens inside quoted values no longer mis-split).
-  - mutations: deleting a property from a session-created pset and replaying
-    `UPDATE_ATTRIBUTE` / `CREATE_PROPERTY_SET` mutations now work.
-  - export: merged-export ID remapping no longer rewrites `#N` inside quoted strings.
-  - drawing-2d: GPU section cutter triangle upload/readback use correct WGSL std-layout
-    offsets and strides.
-  - ifcx: cyclic children no longer abort the parse; spatial children round-trip; the
-    mesh transform guards a zero/non-finite homogeneous `w`.
-  - data / cache: a `NULL` string property value stays `null` instead of becoming `""`.
-  - pointcloud, bcf, server-client, query, viewer-core, viewer store/federation: assorted
-    decoding, federation-id, and selection-state fixes.
-
-  **Resource / memory leaks**
-
-  - geometry, query (DuckDB), renderer (GPU buffers), collab (federation presence),
-    sandbox (host log capture + runtime), mcp (clash mesh cache), server-bin (signal
-    listeners), and the viewer renderer on unmount now release resources deterministically.
-
-  **Hardening (apps, not published)**
-
-  - server: a dedicated `server-release` Cargo profile (`panic = "unwind"`) plus a
-    `CatchPanicLayer` contain a malformed-IFC parse panic to the offending request
-    instead of aborting the whole server.
-  - desktop (Tauri): a Content-Security-Policy is set, and unused `shell:*` /
-    `fs:allow-write|mkdir|remove` capabilities (and the unused shell plugin) are removed.
-
-  **Second pass** (additional verified findings)
-
-  - collab-server: S3 log load now follows `ListObjectsV2` pagination (no dropped frames);
-    awareness frames are size-capped + rate-limited; path-lock verify runs after role/rate-limit;
-    the blob route requires auth and `/metrics` can be token-gated.
-  - server-bin: downloaded binaries are SHA-256 verified against a release sidecar (fail-closed on
-    mismatch, warn-if-absent for older releases).
-  - extensions: inner-ring capability check fails _closed_ for unknown namespaces; signing
-    canonicalization is now injective (length-prefixed).
-  - correctness/leaks: mutations quantity type+unit preserved on replay; `findByProperty` boolean
-    comparisons; Parquet REAL columns kept as Float64; blob GC fail-safe on missing `uploadedAt`;
-    spatial-hierarchy + codegen cycle guards; BVH NaN edge; bSDD/playground caches bounded;
-    point-cloud GPU asset freed on federation error; mcp `parseColor` rejects non-hex; bcf/SVG/STEP
-    output escaping; and more.
-
-## 1.15.2
-
-### Patch Changes
-
-- [#494](https://github.com/louistrue/ifc-lite/pull/494) [`ec0d3a0`](https://github.com/louistrue/ifc-lite/commit/ec0d3a0e4c7f9eaeb26ab0a724fd76d955e52ac5) Thanks [@louistrue](https://github.com/louistrue)! - Remove recursive package `prebuild` hooks and run TypeScript via `pnpm exec` so workspace builds resolve correctly on Windows.
-
-## 1.15.1
-
-### Patch Changes
-
-- [#461](https://github.com/louistrue/ifc-lite/pull/461) [`6ce40dd`](https://github.com/louistrue/ifc-lite/commit/6ce40ddb0cace5f83c2438d2d4c4bd47703468f7) Thanks [@louistrue](https://github.com/louistrue)! - Clean up package build health for georeferencing work by fixing parser generation issues, making export tests resolve workspace packages reliably, removing build scripts that masked TypeScript failures, tightening workspace test/build scripts, productizing CLI LOD generation, centralizing IFC GUID utilities in encoding, and adding mutation test coverage for property editing flows.
-
-## 1.15.0
-
-### Minor Changes
-
-- [#354](https://github.com/louistrue/ifc-lite/pull/354) [`3f212f1`](https://github.com/louistrue/ifc-lite/commit/3f212f1e24b896cbc6ff63444c02635a1128ba3f) Thanks [@louistrue](https://github.com/louistrue)! - Replace hardcoded IFC schema with codegen from EXPRESS schema, adding full type entity support (776 entities)
-
-## 1.14.3
-
-## 1.14.2
-
-## 1.14.1
-
-## 1.14.0
-
-## 1.13.0
-
-## 1.12.0
-
-## 1.11.3
-
-## 1.11.1
-
-## 1.11.0
-
-## 1.10.0
-
-## 1.9.0
-
-## 1.8.0
-
-## 1.7.0
-
-## 1.2.1
-
-### Patch Changes
-
-- Version sync with @ifc-lite packages