Integration from Module Schemas to Full Model

From Open Source Ecology
Jump to navigation Jump to search

About

This must be done not by gurus—by clerks following specs.

Why? Because of this - [1]. In short: The real risk is not skill level—it’s unconscious substitution. The danger is not incompetence. The danger is: “I know a better way to do this.”

Howto

The core simplification: Assembly is not geometry. Assembly is topology. Geometry already exists at the module level. Assembly is simply how modules are connected.

If you accept that, everything downstream becomes tractable.

Induction-Grade House Compiler Process (Modules → Assembly → Post-Compilers)

Canonical Principle

All downstream artifacts are generated from:

  1. Module Schemas (single-module truth)
  2. Assembly Schema (topology truth: what connects to what)
  3. Post-Compiler Passes (feature injection + routing + schedules)

No manual CAD edits. Every output must be regenerable from schemas.

Canonical Principle 2

  1. Schemas describe intent
  2. Assemblies describe relationships
  3. Compilers produce geometry

Assembly Canon: Topology, Not Geometry

Canonical Statement

Assembly is not geometry. Assembly is topology.

Assembly declares relationships. Geometry is a derived consequence.

If geometry is specified at the assembly level, automation fails. If topology is specified, geometry becomes compilable.

---

Definitions

Module

A module is a self-contained, parametric unit with:

  • Local coordinate system (CSYS)
  • Known dimensions
  • Named connection ports (left, right, top, bottom, etc.)
  • Published metadata (stud map, faces, no-go zones)

Modules contain geometry. Assemblies do not.

Assembly

An assembly is a connection graph consisting only of:

  • Module instances
  • Connections between module ports

An assembly answers:

  • What exists?
  • What connects to what?
  • Through which ports?

Nothing else.

---

What Assembly Explicitly Does NOT Contain

Assembly definitions must never include:

  • Coordinates (X, Y, Z)
  • Absolute positions
  • Offsets or dimensions
  • Angles or rotations (except implicit via port orientation)
  • Solids or sketches
  • Boolean operations
  • Manual placement decisions

Any of the above indicates a broken abstraction.

---

Topology Is Sufficient

Given:

  • Modules with known geometry and ports
  • A graph of connections between ports

The assembly compiler can:

  1. Place a root module at origin
  2. Traverse the adjacency graph
  3. Align ports and propagate transforms
  4. Generate full building geometry deterministically

No additional information is required.

---

Assembly Schema (Minimum Viable)

An assembly schema contains only:

  • modules[]
 * module_id
 * module_type
 * parameters
 * orientation (discrete or implicit)
 * level (optional)
  • connections[]
 * module_A.port_X → module_B.port_Y
 * (optional) connection type: L / T / splice

This schema is human-readable and human-authored.

---

Why Assembly Must Be Topological

Topology is:

  • Stable under change
  • Regenerable
  • Deterministic
  • Auditable
  • Suitable for rule-based automation

Geometry is:

  • Fragile
  • Context-dependent
  • Hard to regenerate
  • Prone to manual drift

Assemblies must survive change. Geometry does not.

Consequences for Automation

When topology is explicit:

  • Corners are known (L-connections)
  • T-walls are known (mid-span connections)
  • Splices are known (collinear connections)

Therefore:

  • Blocking rules trigger from connection types
  • Electrical boxes place along wall sequences
  • Plumbing and wiring become graph routing problems
  • Feature injection becomes deterministic

No geometric inference hacks are required.

Assembly vs Post-Compilers

Assembly compiler responsibilities:

  • Place modules
  • Record adjacency
  • Emit connection events

Assembly compiler must:

  • Make no design decisions
  • Inject no features
  • Modify no modules

All construction logic occurs in post-compilers.

Invariants (Non-Negotiable)

  • Assemblies are declarative, not procedural
  • Assemblies contain no geometry
  • Geometry is always regenerated
  • Manual edits are forbidden
  • Every downstream artifact must trace back to topology

Violating any invariant breaks induction.

Canonical Takeaway

Assembly defines relationships. Compilers derive geometry. Rules inject features.

This separation is what makes houses, machines, and infrastructure compilable.

Lock this canon before writing code.

Retrieved from "https://wiki.opensourceecology.org/index.php?title=Integration_from_Module_Schemas_to_Full_Model&oldid=319012"