Instrumento 3D Central · WebGL2 y Verificación a Nivel de Bytes · X.01 (TOOL-CORE-1) · 22 min de lectura
Cómo un módulo ES sin dependencias analiza archivos binarios glTF 2.0 (GLB) en WebGL2 puro mientras un verificador en Python stdlib demuestra hermeticidad 2-variedad, volumen por el teorema de la divergencia y rechazo de binarios corruptos.
La mayoría de los visores 3D web descargan megabytes de librerías externas y confían ciegamente en cualquier archivo binario. Para ingenieros independientes, pequeños despachos de arquitectura e investigadores, verificar por qué una malla es hermética—e inspeccionar sus bloques binarios, característica de Euler y volumen con signo sin dependencias—convierte archivos CAD opacos en objetos matemáticos auditables.
Descarga directamente la malla 3D, el sólido STEP, el paquete 3MF o el plano DXF verificados con SHA-256:
Abre .glb en Blender 4.2+ (File → Import → glTF 2.0), .step en FreeCAD 1.0 o build123d / CadQuery, .3mf en OrcaSlicer / PrusaSlicer, o .dxf en QCAD Community Edition / LibreCAD / Inkscape.
Ejecuta python skills/toolchain/x01/make_x01.py para generar dimensiones personalizadas y python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py para verificar la geometría en <1s.
Actos I y II — Historia, ley geométrica e intuición cotidiana: Visor WebGL2 GLB sin Dependencias y Verificador Geométrico 2-Variedad a Nivel de Bytes — Cómo un módulo ES sin dependencias analiza archivos binarios glTF 2.0 (GLB) en WebGL2 puro mientras un verificador en Python stdlib demuestra hermeticidad 2-variedad, volumen por el teorema de la divergencia y rechazo de binarios corruptos. Este monográfico interactivo verifica la ley geométrica V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E. Por qué importa en el estudio y taller: La mayoría de los visores 3D web descargan megabytes de librerías externas y confían ciegamente en cualquier archivo binario. Para ingenieros independientes, pequeños despachos de arquitectura e investigadores, verificar por qué una malla es hermética—e inspeccionar sus bloques binarios, característica de Euler y volumen con signo sin dependencias—convierte archivos CAD opacos en objetos matemáticos auditables.
En Palabras Sencillas (Explicación Accesible): Para entender una malla tridimensional de forma sencilla, imaginen un balón de fútbol armado con parches de cuero cosidos a mano. Para que el balón retenga el aire y no se desinfle, cada costura debe unir exactamente dos paneles adyacentes, sin dejar ningún orificio abierto y sin amontonar telas. Además, todos los parches deben mirar hacia afuera con el lado liso al exterior. En el diseño digital ocurre exactamente lo mismo: un modelo tridimensional está compuesto por pequeños triángulos planos que deben formar una cáscara perfectamente sellada. Con frecuencia, cuando exportamos archivos entre diferentes programas de diseño, algunas caras se voltean hacia adentro o quedan pequeñas grietas invisibles en la pantalla. Este visor gratuito en el navegador web les permite abrir y girar piezas en tres dimensiones directamente, inspeccionar cortes transversales y comprobar que cada triángulo esté bien colocado. Con un solo clic, cualquier estudiante, diseñador o taller independiente puede descargar modelos verificados y rutinas en Python para revisar sus geometrías sin gastar en licencias costosas.
Mecanismo Técnico, Fuerzas en Competencia y Umbral Crítico: La integridad matemática de una superficie poligonal descansa en la rigurosa equivalencia entre la topología discreta y el análisis vectorial clásico. Mediante el teorema de divergencia de Gauss-Ostrogradsky, el volumen encerrado por una variedad bidimensional cerrada se calcula exactamente a través de la suma de productos triples escalares sobre sus triángulos frontera. Para que esta formulación conserve validez, cada arista dirigida de la malla debe cancelarse con su semi-arista gemela orientada en sentido inverso, garantizando la condición de variedad bidimensional y preservando la característica de Euler igual a dos en sólidos de género cero. Cuando un modelo se transfiere en formato binario GLB, nuestro módulo analiza la cabecera de doce bytes y valida los límites de los bloques de memoria sin requerir dependencias externas de JavaScript. Si una sola cara invierte su orientación, el signo de su contribución volumétrica cambia inmediatamente y el emparejamiento de semi-aristas colapsa, permitiendo a ingenieros y despachos independientes certificar geometrías con absoluta precisión numérica.
Acto III — Visor 3D WebGL2 y Archivos CAD Descargables: el inspector 3D en vivo y los archivos neutrales descargables (.glb, .step, .3mf, .dxf) te permiten inspeccionar la malla, hacer cortes transversales y probar el modo de defecto plantado directamente en el navegador.
Actos IV y V — Kit para pequeños estudios, generador en Python y fuentes: descarga skills/toolchain/x01/make_x01.py, skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py y SKILL.md. Cálculo educativo y exploratorio únicamente, no un diseño estructural firmado.
Para entender una malla tridimensional de forma sencilla, imaginen un balón de fútbol armado con parches de cuero cosidos a mano. Para que el balón retenga el aire y no se desinfle, cada costura debe unir exactamente dos paneles adyacentes, sin dejar ningún orificio abierto y sin amontonar telas. Además, todos los parches deben mirar hacia afuera con el lado liso al exterior. En el diseño digital ocurre exactamente lo mismo: un modelo tridimensional está compuesto por pequeños triángulos planos que deben formar una cáscara perfectamente sellada. Con frecuencia, cuando exportamos archivos entre diferentes programas de diseño, algunas caras se voltean hacia adentro o quedan pequeñas grietas invisibles en la pantalla. Este visor gratuito en el navegador web les permite abrir y girar piezas en tres dimensiones directamente, inspeccionar cortes transversales y comprobar que cada triángulo esté bien colocado. Con un solo clic, cualquier estudiante, diseñador o taller independiente puede descargar modelos verificados y rutinas en Python para revisar sus geometrías sin gastar en licencias costosas.
En 1752, Leonhard Euler examinó poliedros de madera y papel en Berlín y descubrió un invariante asombroso: sin importar cómo se divida un sólido convexo sin túneles, el número de vértices menos aristas más caras siempre es igual a 2 (V − E + F = 2). Casi un siglo después, Carl Friedrich Gauss y Mikhail Ostrogradsky demostraron que el volumen interior exacto de cualquier cáscara cerrada puede medirse integrando únicamente sobre su superficie frontera.
Cuando nacieron los gráficos por computadora en los años setenta, Bruce Baumgart inventó las estructuras de arista alada y semi-arista para comprobar si las mallas digitales formaban sólidos cerrados. Entre 2017 y 2022, el Khronos Group estandarizó glTF 2.0 (.glb) como la norma ISO/IEC 12113:2022, empaquetando grafos JSON y búferes binarios IEEE-754 en un solo archivo compacto que nuestro inspector en Python y WebGL2 verifica byte por byte.
Euler demuestra que todo poliedro convexo cumple el invariante topológico V − E + F = 2, fundando la topología combinatoria.
Obstáculo Clásico: Aún no existía una fórmula de coordenadas para calcular el volumen desde triángulos superficiales.Demuestra que el volumen interior equivale a un tercio de la integral de flujo superficial del vector posición.
Obstáculo Clásico: Las normales invertidas restan volumen silenciosamente en lugar de sumarlo.Introduce el emparejamiento de aristas dirigidas para detectar grietas y costuras no-variedad en mallas 3D.
Obstáculo Clásico: Formatos antiguos como OBJ y STL descartaban las tablas de adyacencia.Estandariza la cabecera GLB de 12 bytes, el descriptor JSON y los búferes binarios alineados para GPU.
Obstáculo Clásico: Longitudes de bloque corruptas provocan lecturas fuera de rango si no se auditan.Certifica alineación GLB de 1,708 B, cierre 3F = 2E, χ = 2, V = 24,000 mm³ y rechazo de 4/4 pruebas fuzz.
Obstáculo Clásico: Geometría educativa únicamente; la fabricación física exige pruebas de materiales.En el verano de 1752, Leonhard Euler examinó modelos de poliedros de madera sobre su escritorio en la Academia de Ciencias de Berlín, buscando un orden oculto detrás de las facetas geométricas. Durante dos milenios, desde Euclides hasta los tratados de perspectiva de Alberto Durero en el Renacimiento, los artesanos habían clasificado los sólidos únicamente por su simetría visual. Euler descubrió algo mucho más profundo: sin importar cómo se corte o deforme un bloque cerrado sin agujeros, el número de vértices menos las aristas más las caras siempre es igual a dos. Casi un siglo después, Carl Friedrich Gauss y Mikhail Ostrogradsky demostraron que el volumen interior de cualquier sólido cerrado puede calcularse integrando únicamente sobre su superficie exterior. En los años setenta, Bruce Baumgart tradujo esa sabiduría en la estructura de datos de arista alada en Stanford, sentando las bases topológicas de la computación gráfica moderna.
A medida que los gráficos tridimensionales migraron de las estaciones de trabajo de laboratorio a la web moderna, el intercambio de geometría enfrentó una crisis de fragmentación. Los formatos antiguos almacenaban mallas como texto plano pesado o archivos binarios incompatibles, obligando a los navegadores a analizar millones de cadenas de caracteres antes de dibujar un solo triángulo. Para resolver este cuello de botella, el Khronos Group introdujo la especificación glTF 2.0, ratificada internacionalmente como ISO/IEC 12113:2022. Su contenedor binario (.glb) empaqueta un grafo de escena JSON estructurado junto con búferes binarios crudos listos para la memoria de la GPU. En el Folio X.01 combinamos esta transmisión binaria eficiente con el cálculo exterior discreto (Desbrun et al., 2005; DOI: 10.1145/1198555.1198666). Nuestro inspector WebGL2 sin dependencias lee el archivo binario byte por byte, verifica la paridad de semi-aristas dirigidas y evalúa el volumen firmado por divergencia en tiempo real.
Para un pequeño despacho de arquitectura o un ingeniero independiente, un archivo tridimensional corrupto puede arruinar días de trabajo antes de que nadie note el defecto. Un modelo descargado o exportado con prisa suele parecer impecable bajo el sombreado de pantalla, ocultando caras invertidas, grietas microscópicas o longitudes de búfer truncadas. Cuando ese archivo llega a un laminador de impresión 3D, a un verificador de interferencias BIM o a una fresadora CNC, las consecuencias son inmediatas: el software de corte falla, los cálculos de volumen arrojan cifras negativas o las herramientas de corte colisionan. Al integrar un verificador determinista a nivel de bytes directamente en Python estándar y en el navegador, eliminamos la dependencia de costosas suites comerciales de reparación.
Flujo de Estudio sin Costo (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Ejecuta make_x01.py para generar x01_artifact.glb, x01_artifact.step y x01_artifact.3mf; audita cualquier malla .glb en busca de bordes no-variedad, normales invertidas o bloques corruptos en < 0.05s antes de enviarla a corte o BIM.
Toda herramienta duradera de ingeniería y arquitectura nace del esfuerzo humano por convertir el oficio tácito del taller en un lenguaje auditable y compartible. Trazar la evolución de la Herramienta X.01 (TOOL-CORE-1) desde su primera formulación en 1752 (Leonhard Euler formulates the polyhedral invariant V − E + F = 2 for convex and genus-0 closed polyhedra.) hasta su implementación abierta moderna en 2026 (Informatico.ai ships X.01: a zero-dependency WebGL2 GLB inspector paired with a Python 3 stdlib byte-level manifold verifier and 4-case fuzz harness.) revela por qué los formatos binarios cerrados y las exportaciones de polígonos sin verificar frenaron repetidamente a los estudios pequeños. Siempre que un estudio o taller intercambia geometría sin un invariante matemático explícito—gobernado aquí por V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E—defectos topológicos silenciosos corrompen el paso entre el diseño y la fabricación física.
Resolver ese cuello de botella exige combinar especificaciones neutrales libres de regalías (.glb, .step AP242, .3mf, .dxf) con un generador en código sin dependencias (skills/toolchain/x01/make_x01.py) y un verificador determinista a nivel de bytes (skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py). Cada archivo exportado se trata no como un dibujo opaco, sino como un certificado matemático falsable cuya cronología de avances se resume a continuación:
| Año | Hito y Ancla de Verificación |
|---|---|
| 1752 | Leonhard Euler formula el invariante poliédrico V − E + F = 2 para poliedros convexos. |
| 1813–1826 | Carl Friedrich Gauss y Mikhail Ostrogradsky formulan el teorema de divergencia, permitiendo calcular volúmenes exactos desde triángulos de frontera. |
| 1991 | Bruce Baumgart introduce la topología de arista alada (precursora de la estructura de semi-aristas) para representar variedades 2D orientables. |
| 2017–2022 | El Khronos Group publica glTF 2.0 y la norma ISO/IEC 12113:2022 para contenedores binarios 3D .glb. |
| 2026 | Informatico.ai ships X.01: a zero-dependency WebGL2 GLB inspector paired with a Python 3 stdlib byte-level manifold verifier and 4-case fuzz harness. |
Una malla 3D no está verificada porque se vea bien sombreada en pantalla; está verificada cuando su cabecera binaria cuadra al byte, cada arista dirigida cancela su gemela opuesta y su integral de divergencia iguala el volumen analítico.
Analogía Cotidiana: Imagina coser a mano un balón de fútbol clásico con treinta y dos paneles de cuero. Para que la cámara interior retenga el aire a presión, cada costura debe unir exactamente dos bordes adyacentes sin dejar huecos ni coser tres parches en la misma línea. Además, cada pieza de cuero debe colocarse con la cara impresa hacia afuera. Una malla 3D hermética funciona exactamente bajo la misma regla artesanal.
Cómo Funcionan los Dos Deslizadores y el Modo de Fallo en Palabras Sencillas: En el laboratorio interactivo puedes poner a prueba estas leyes geométricas con dos deslizadores y el botón de defecto plantado. El primer deslizador ajusta la longitud del bloque de calibración (L_x) y el segundo controla la altura (L_z), actualizando al instante el volumen por divergencia y escalando la malla 3D en vivo. Al pulsar el botón de Defecto Plantado (Knockout), el sistema invierte el orden de giro de un triángulo en memoria, rompiendo la cancelación de semi-aristas y disparando la alerta roja del verificador.
Imagina una caja de zapatos cerrada con 6 caras de cartón, 8 esquinas y 12 bordes encintados: 8 − 12 + 6 = 2 (invariante de Euler χ = 2). Cada borde encintado une exactamente 2 paneles en sentidos opuestos.
Ahora despega la tapa superior, voltéala al revés y vuelve a colocarla. A simple vista la caja parece cerrada, pero dos leyes matemáticas se rompen al instante: los bordes dirigidos de la tapa ahora corren en el MISMO sentido que las paredes laterales (rompiendo la cancelación de semi-aristas) y el teorema de divergencia resta la pirámide de la tapa en lugar de sumarla. Así detecta verify_x01 un solo triángulo invertido en menos de un milisegundo.
Para verificar la integridad geométrica sin inspección visual subjetiva, el verificador evalúa tres invariantes acoplados directamente desde el flujo binario. Primero, el teorema de divergencia discreto calcula el volumen encerrado exacto sumando determinantes tetraédricos firmados desde el origen hasta cada triángulo frontera: V = (1/6) ∑ v_0 · (v_1 × v_2) = 24,000.0 mm³. Si una sola normal apunta hacia adentro, su signo se invierte y corrompe la suma volumétrica. Segundo, la topología combinatoria exige que en una malla triangular cerrada cada cara aporte tres semi-aristas dirigidas y cada arista física sea compartida por dos caras opuestas, imponiendo 3F = 2E (con F = 24 y E = 36, 72 = 72). Tercero, la característica de Euler–Poincaré certifica el cierre de género cero: χ = V − E + F = 14 − 36 + 24 = 2.
Acoplamiento de parámetros en vivo: 40 mm
y 20 mm
bajo la ley gobernante V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E.
En el nivel de bytes, un contenedor binario GLB inicia con un preámbulo de 12 bytes en formato little-endian: el número mágico 0x46546C67 ('glTF'), la versión 2 y la longitud total exacta de 1,708 bytes. Le siguen dos bloques alineados a múltiplos de 4 bytes: el bloque JSON (0x4E4F534A) que describe la escena y los accesores, y el bloque BIN (0x004E4942) con los arreglos contiguos Float32 de posiciones y normales seguidos por los índices Uint32. Nuestro verificador valida que ningún desplazamiento de byte exceda el bloque binario antes de construir el grafo de semi-aristas.
V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
En la Herramienta X.01 (Visor WebGL2 GLB sin Dependencias y Verificador Geométrico 2-Variedad a Nivel de Bytes), la fuente de verdad es el código (skills/toolchain/x01/make_x01.py), nunca un archivo binario sin auditar. El generador emite archivos neutrales deterministas mientras el verificador stdlib skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py comprueba los límites binarios, la estanqueidad de aristas, el volumen con signo, la caja delimitadora y los hashes SHA-256.
Al expresar la geometría sobre una variedad de estados bien planteada en lugar de un árbol frágil de clics manuales en interfaz gráfica, cualquier pequeño estudio o ingeniero independiente puede auditar el mapeo exacto desde los parámetros de entrada hasta las coordenadas de vértices, bucles B-Rep y polilíneas de corte 2D. Cada coordenada es acotada, finita y reproducible al byte en Windows, macOS y Linux.
En lugar de tratar V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E como una caja negra opaca, descomponemos la generación geométrica y la verificación a nivel de bytes de la Herramienta X.01 en cuatro etapas explícitas e inspeccionables. Las verdaderas herramientas de ingeniería y arquitectura no piden fe ciega; invitan a la inspección en cada paso:
Mecanismo Formal de Etapa: Etapa 1: Validación de Encabezado Binario GLB y Límites de Bloque — Verificar magic == 0x46546C67, version == 2, alineación de 4 bytes y que cada bufferView caiga dentro del bloque BIN.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 1 de la Herramienta X.01 (TOOL-CORE-1), el generador skills/toolchain/x01/make_x01.py y el verificador stdlib skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py imponen la ley geométrica gobernante V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E junto con el invariante complementario: Integridad de Contenedor Binario (ISO/IEC 12113:2022): El encabezado de 12 bytes debe coincidir con la longitud real del archivo (1,708 bytes) y ningún accesor puede exceder el bloque BIN.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 1 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x01/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 2: Construcción del Grafo de Semi-Aristas Dirigidas — Por cada triángulo (i0, i1, i2), registrar las semi-aristas (i0→i1), (i1→i2), (i2→i0) y verificar que cada (u→v) tenga exactamente una gemela inversa (v→u).
Clausura de Invariantes a Nivel de Bytes: En la Etapa 2 de la Herramienta X.01 (TOOL-CORE-1), el generador skills/toolchain/x01/make_x01.py y el verificador stdlib skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py imponen la ley geométrica gobernante V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E junto con el invariante complementario: Cierre 2-Variedad de Semi-Aristas: Cada arista dirigida (u, v) debe aparecer a lo sumo una vez y emparejarse exactamente con su gemela opuesta (v, u), cumpliendo 3F = 2E y χ = 2.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 2 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x01/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 3: Certificación de Característica de Euler–Poincaré — Contar vértices únicos V = 14, aristas no dirigidas E = 36 y caras F = 24 para certificar 3F = 2E y χ = V − E + F = 2.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 3 de la Herramienta X.01 (TOOL-CORE-1), el generador skills/toolchain/x01/make_x01.py y el verificador stdlib skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py imponen la ley geométrica gobernante V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E junto con el invariante complementario: Conservación de Volumen y Compuerta de Defecto Plantado: El volumen firmado por divergencia debe igualar 24,000.0 mm³ (±10⁻⁵) y el verificador debe rechazar las 4 mutaciones fuzz y el triángulo invertido.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 3 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x01/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 4: Integración de Volumen por Divergencia y Knockout de Defecto Plantado — Sumar (1/6) v0 · (v1 × v2) = 24,000.0 mm³ y verificar que al invertir un triángulo o truncar el encabezado el verificador rechace el archivo.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 4 de la Herramienta X.01 (TOOL-CORE-1), el generador skills/toolchain/x01/make_x01.py y el verificador stdlib skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py imponen la ley geométrica gobernante V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E junto con el invariante complementario: Integridad de Contenedor Binario (ISO/IEC 12113:2022): El encabezado de 12 bytes debe coincidir con la longitud real del archivo (1,708 bytes) y ningún accesor puede exceder el bloque BIN.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 4 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x01/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Cada archivo neutral y lectura numérica en la Herramienta X.01 está gobernado por tres invariantes de falsación verificados por máquina en toolchain-x01-glb-inspector-validator-SKILL.md y ejecutados fuera de línea por skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py:
En conjunto, los Invariantes X.01-R1 a X.01-R3 cierran el ciclo de verificación entre el diseño paramétrico y el intercambio CAD neutral. Si cualquier cambio de parámetro, exportación de malla o modificación de código por IA viola estas cotas, el verificador stdlib termina con código de error e identifica el invariante violado antes de desperdiciar material.
Nota Estructural Primaria (NOTA AL MARGEN X.01-A · POR QUÉ IMPORTA EL FUZZING DE ENCABEZADOS GLB): Los visores 3D suelen confiar ciegamente en las longitudes declaradas en el JSON. Un archivo .glb truncado o malicioso puede declarar un byteLength mayor que el bloque BIN real. Nuestro verificador audita cuatro vectores fuzz independientes antes de leer geometría.
Nota de Verificación Secundaria (NOTA AL MARGEN X.01-B · TEOREMA DE DIVERGENCIA EN UNIDAD DE PUNTO FLOTANTE): Sumar (1/6) det(v0, v1, v2) sobre los 24 triángulos orientados evalúa el teorema de Gauss–Ostrogradsky de forma exacta para cualquier poliedro plano, detectando al instante cualquier normal invertida.
Por Qué Todo Verificador Debe Demostrar que Puede Fallar: Un script de verificación que siempre imprime PASS es indistinguible de un sello de goma. Por eso skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py incluye una prueba canario automatizada con defecto plantado: clona la geometría válida en memoria, inyecta el defecto topológico o cinemático descrito arriba y comprueba que el verificador rechace el artefacto corrupto antes de certificar la compilación.
Cada archivo abajo es generado deterministamente por skills/toolchain/x01/make_x01.py y verificado byte por byte contra manifest.json. Haz clic en cualquier tarjeta para descargar el artefacto neutral y abrirlo directamente en software 100% libre y gratuito (Blender 4.2+, FreeCAD 1.0, Bonsai BIM, OrcaSlicer, PrusaSlicer, QCAD Community Edition, LibreCAD, Inkscape):
Régimen Geométrico Certificado (X.01) — Las 4 etapas e invariantes se cumplen (skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py).
Arrastra cualquiera de los deslizadores para escalar la malla 3D WebGL2 en vivo y haz clic en Exportar para generar un archivo .glb, .step o .dxf a medida directamente en tu navegador.
Para verificar manualmente o en una tubería de control de calidad del estudio el Visor 3D y el Banco Interactivo anteriores, evaluamos V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E en el punto operativo canónico sobre los artefactos en src/research/toolchain/x01/files/.
| Verificación Geométrica / Formato | Valor Certificado del Artefacto | Verificador Stdlib |
|---|---|---|
| Encabezado y Bloques GLB (ISO/IEC 12113) | glTF v2 · 1,708 B (PASS) | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| Cierre 2-Variedad (3F = 2E) | V=14, E=36, F=24 · χ=2 | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| Volumen Firmado por Divergencia V | 24,000.0 mm³ (err = 0.00%) | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
| Knockout de Defecto Plantado y Fuzz | 4/4 Fuzz + Defect REJECTED | skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py · PASS |
Ejecutar python skills/toolchain/x01/make_x01.py seguido de python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py desde la raíz del repositorio regenera cada artefacto CAD neutral desde cero y ejecuta la batería completa de aserciones topológicas y a nivel de bytes en menos de 1 segundo usando únicamente la biblioteca estándar de Python 3.11+.
Cuando un arquitecto o ingeniero pide a un asistente de IA generar un script de geometría 3D, los modelos de lenguaje suelen cometer errores sutiles de orientación de caras o desalineación de búferes. El Folio X.01 establece un protocolo seguro de co-diseño humano-IA: el humano define las dimensiones y el propósito del componente, el agente ejecuta make_x01.py guiado por el archivo SKILL.md, y el verificador determinista verify_x01 audita cada byte antes de aceptar el archivo.
Los principios topológicos del Folio X.01 conectan las cuatro disciplinas de Informatico.ai: en Arquitectura, la estática gráfica poliédrica (Folio A.11) requiere celdas recíprocas cerradas; en Ingeniería, la impresión 3D de concreto (Folio E.10) y la optimización topológica SIMP (Folio E.11) exigen fronteras variedad estancas; y en Matemáticas, la homología persistente (Folio M.10) generaliza la característica de Euler a complejos simpliciales multiescala.
Cada herramienta en Tech & Tools · El Taller está diseñada como un puente operativo entre los cuatro pilares centrales de Informatico.ai—conectando invariantes matemáticos formales y leyes físicas directamente con la arquitectura de estudio y la fabricación en ingeniería. Explora los Folios conectados y especificaciones abiertas vinculadas con la Herramienta X.01 abajo:
Todos los componentes activos para la Herramienta X.01 están auditados en skills/toolchain/licenses.json para garantizar licencias permisivas (MIT, Apache-2.0, MPL-2.0, LGPL-2.1) sin contaminación copyleft en los scripts ni en los artefactos 3D neutrales.
A continuación se muestran los scripts completos en Python 3 que generan y verifican la Herramienta X.01 (TOOL-CORE-1). Como el código es la fuente primaria de verdad, puedes inspeccionar cada ecuación, buffer de vértices, entidad STEP y prueba de defecto plantado en esta misma página o ejecutarlos en tu propia máquina:
#!/usr/bin/env python3
"""Deterministic Geometry Generator for Toolbox X.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import generate_folio_assets # noqa: E402
def main() -> int:
files_dir = ROOT / "src" / "research" / "toolchain" / "x01" / "files"
manifest = generate_folio_assets(
slug="x01",
folio_id="X.01",
title="Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier",
script_path=Path(__file__).resolve(),
files_dir=files_dir,
formats=('glb', 'step', '3mf'),
)
print(json.dumps({"status": "GENERATED", "folio_id": "X.01", "files": [f["filename"] for f in manifest["files"]]}, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
Governing Law: V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x01" / "files"
make_script = Path(__file__).resolve().parent / "make_x01.py"
try:
result = verify_folio_assets(
slug="x01",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.01", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())
Equipa a tu estudio o agente de IA con el flujo de trabajo neutral, las reglas de exportación en formatos abiertos y el verificador a nivel de bytes de la Herramienta X.01 (TOOL-CORE-1): descarga toolchain-x01-glb-inspector-validator-SKILL.md o verify_x01_toolchain_x01_glb_inspector_validator.py.
SKILL.md source---
name: toolchain-x01-glb-inspector-validator
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.01 (TOOL-CORE-1) - Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier (X.01 · TOOL-CORE-1)
> **Fixed Educational Boundary (`EN`):** Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
>
> **Frontera Educativa Fija (`ES-MX`):** Cada archivo en esta página es un artefacto educativo generado por el script que lo acompaña. Nada aquí está certificado como estructural, imprimible, seguro ni apto para ningún propósito. El verificador comprueba la geometría, no la aptitud.
## 1. Governing Law, Open Standard & Canonical URL
- **Toolbox Folio**: `X.01` (`TOOL-CORE-1` · `REV 1.2`, Redated `2026-11-09`)
- **Canonical URL**: https://informatico.ai/toolchain/x01/ (Spanish: https://informatico.ai/es-mx/toolchain/x01/)
- **Track Badge**: TOOLBOX X.01 · ZERO-BUILD WEBGL2 GLB INSPECTOR + STDLIB VALIDATOR
- **Reference Standard / Repository**: [Khronos glTF 2.0 Specification (ISO/IEC 12113)](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html)
- **Governing Equation**: `V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E`
- **Deterministic Generator**: `python skills/toolchain/x01/make_x01.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1145/3596711.3596790 (Scite Report: https://scite.ai/reports/10.1145/3596711.3596790)
## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Zero-Cost Studio Workflow (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Run make_x01.py to emit x01_artifact.glb, x01_artifact.step, and x01_artifact.3mf; audit any client or subcontractor .glb mesh for non-manifold edges, inverted normals, or chunk corruption in < 0.05s before opening a slicer or BIM model.
- **ES-MX**: Flujo de Estudio sin Costo (Blender 4.2 + FreeCAD 1.0 + Python 3 stdlib): Ejecuta make_x01.py para generar x01_artifact.glb, x01_artifact.step y x01_artifact.3mf; audita cualquier malla .glb en busca de bordes no-variedad, normales invertidas o bloques corruptos en < 0.05s antes de enviarla a corte o BIM.
## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x01/make_x01.py` inside the repository working directory to emit `src/research/toolchain/x01/files/x01_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x01/verify_x01_toolchain_x01_glb_inspector_validator.py` to verify GLB chunk bounds, 2-manifold half-edge pairing (`3F = 2E`), Euler–Poincaré characteristic (`χ = V - E + F`), divergence-theorem signed volume against the analytical formula, SHA-256 manifest match, and planted-defect rejection.
3. **Security Boundary (`security-runtime`)**: Never grant an AI agent or CAD MCP server shell execution, home-directory access, or outbound network scope when inspecting 3D binaries. Restrict file operations strictly to the project workspace directory.
## 4. Deterministic Verification & Falsification Rules
1. Binary Chunk Containment Invariant: Every glTF bufferView byteOffset + byteLength must satisfy 0 ≤ start ≤ end ≤ BIN_byteLength, and every triangle index must be strictly less than POSITION.count.
2. Watertight 2-Manifold Closure Invariant: Every directed half-edge (u, v) must appear exactly once and have a unique reverse half-edge (v, u), enforcing 3F = 2E and χ = V − E + F = 2.
3. Planted-Defect Sensitivity Invariant: Flipping the winding of Triangle 0 ((i_0, i_1, i_2) → (i_0, i_2, i_1)) must immediately trigger duplicate/unpaired half-edge failure and alter the divergence volume.
## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Khronos GLB Binary Header & Chunk Bounds Audit — Unpack the 12-byte header (<3I: magic 0x46546C67, version 2, total_len) and verify that Chunk 0 (JSON) and Chunk 1 (BIN) byte offsets and accessor bufferViews lie strictly within the file.
- Stage 2: Directed Half-Edge Manifold Closure (3F = 2E) — Build the directed half-edge table {(u, v)} across all triangles and assert zero degenerate triangles, zero duplicate half-edges, and 100% reverse half-edge pairing (v, u) ∈ E.
- Stage 3: Euler–Poincaré Characteristic & Divergence-Theorem Volume — Compute χ = V − E + F = 2 − 2g and integrate V_mesh = (1/6) ∑ v_0 · (v_1 × v_2) to certify exact agreement with the analytical solid volume (24,000.0 mm³).
- Stage 4: Malformed-Binary Fuzz Suite & Planted-Defect Knockout — Run the parser and topological verifier against 4 malformed GLB fuzz files (truncated header, chunk OOB, vertex index OOB, flipped normal) and assert that every defect fails.
## 6. Certified Reference Telemetry (T0/T1)
- **GLB Binary Header & Chunks**: `glTF v2 · 1,708 B (PASS)`
- **2-Manifold Topology (V, E, F)**: `V=14, E=36, F=24 · χ=2`
- **Divergence Signed Volume**: `24,000.0 mm³ (err = 0.00%)`
- **Fuzz & Knockout Gate**: `4/4 Fuzz + Defect REJECTED`
## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Zero-dependency WebGL2 GLB loader and interactive orbit/wireframe/clipping inspector in src/research/modules/glb-viewer.mjs.
- Deterministic Python stdlib generator (skills/toolchain/x01/make_x01.py) emitting x01_artifact.glb, x01_artifact.step, x01_artifact.3mf, manifest.json, and 4 malformed fuzz fixtures.
- Byte-level stdlib verifier (verify_x01_toolchain_x01_glb_inspector_validator.py) certifying χ = 2, V = 24,000.0 mm³, SHA-256 manifest match, 4/4 fuzz rejection, and planted-defect knockout.
### Educational Boundary & Edition 2 Horizon (T2/T3)
- Educational Geometry Boundary: Every file on this page is an educational artifact; nothing is certified as load-bearing, printable, safe, or fit for any purpose.
- Future Edition 2 Extensions: Skeletal animation tracks, Draco/Meshopt compressed buffer views, and KTX2 GPU texture transcoding remain outside the v1 static-mesh subset.
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.01 (TOOL-CORE-1): Zero-Build WebGL2 GLB Inspector & Byte-Level 2-Manifold Geometry Verifier.
Canonical URL: https://informatico.ai/toolchain/x01/
Governing Law: V = (1/6) ∑_{f ∈ F} v_0 · (v_1 × v_2) · χ = V − E + F = 2 − 2g · 3F = 2E
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x01" / "files"
make_script = Path(__file__).resolve().parent / "make_x01.py"
try:
result = verify_folio_assets(
slug="x01",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.01", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())