@pascal-app/core 0.9.2 → 1.0.0-beta.1

package/dist/schema/asset-url.test.js

@@ -1,134 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { ALLOWED_ORIGINS_ENV, AssetUrl } from './asset-url';
-function isValid(url) {
-    return AssetUrl.safeParse(url).success;
-}
-describe('AssetUrl', () => {
-    describe('allowed URLs', () => {
-        const cases = [
-            ['asset://abc', 'internal asset handle'],
-            ['asset://catalog/items/chair-1', 'nested asset handle'],
-            ['blob:http://example.com/uuid-1234', 'blob URL with http inner'],
-            ['blob:https://example.com/uuid-5678', 'blob URL with https inner'],
-            ['https://cdn.example.com/a.glb', 'https CDN URL'],
-            ['https://cdn.example.com/models/chair.glb?v=2', 'https URL with query string'],
-            ['http://localhost:3000/x', 'http localhost with port'],
-            ['http://localhost/x', 'http localhost without port'],
-            ['http://127.0.0.1:8080/texture.png', 'http 127.0.0.1 loopback'],
-            ['/public/a.glb', 'app-relative path'],
-            ['/material/wood1/albedoMap_basecolor.jpg', 'relative path deep'],
-            ['data:image/png;base64,AAA', 'inline PNG data URL'],
-            ['data:image/jpeg;base64,/9j/', 'inline JPEG data URL'],
-            ['data:image/webp;base64,UklGR', 'inline WebP data URL'],
-            ['data:image/svg+xml,%3Csvg%3E', 'inline SVG data URL'],
-        ];
-        for (const [url, label] of cases) {
-            test(`accepts ${label}: ${url}`, () => {
-                expect(isValid(url)).toBe(true);
-            });
-        }
-    });
-    describe('rejected URLs', () => {
-        const cases = [
-            ['javascript:alert(1)', 'javascript scheme'],
-            ['JAVASCRIPT:alert(1)', 'javascript scheme uppercase'],
-            ['file:///etc/passwd', 'file scheme'],
-            ['file://C:/Windows/System32/config', 'file scheme Windows'],
-            ['http://evil.com/', 'non-loopback http'],
-            ['http://example.com:3000/x', 'http on non-loopback host'],
-            ['http://169.254.169.254/latest/meta-data/', 'http on link-local (cloud metadata)'],
-            ['data:text/html,<script>alert(1)</script>', 'data text/html'],
-            ['data:application/javascript,alert(1)', 'data application/javascript'],
-            ['data:text/plain,hi', 'data text/plain'],
-            ['ftp://a.b.com', 'ftp scheme'],
-            ['ws://example.com/', 'websocket scheme'],
-            ['vbscript:msgbox', 'vbscript scheme'],
-            ['', 'empty string'],
-            ['not a url at all', 'non-url string'],
-            ['://missing-scheme', 'malformed'],
-        ];
-        for (const [url, label] of cases) {
-            test(`rejects ${label}: ${url}`, () => {
-                expect(isValid(url)).toBe(false);
-            });
-        }
-    });
-    describe(`env allowlist via ${ALLOWED_ORIGINS_ENV}`, () => {
-        const g = globalThis;
-        const original = g.process?.env?.[ALLOWED_ORIGINS_ENV];
-        beforeEach(() => {
-            if (g.process?.env)
-                delete g.process.env[ALLOWED_ORIGINS_ENV];
-        });
-        afterEach(() => {
-            if (!g.process?.env)
-                return;
-            if (original === undefined) {
-                delete g.process.env[ALLOWED_ORIGINS_ENV];
-            }
-            else {
-                g.process.env[ALLOWED_ORIGINS_ENV] = original;
-            }
-        });
-        test('single origin allowlist accepts matching https URL', () => {
-            if (!g.process?.env)
-                return; // browser-only runtime
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app';
-            expect(isValid('https://cdn.pascal.app/a.glb')).toBe(true);
-            expect(isValid('https://cdn.pascal.app/deep/path?q=1')).toBe(true);
-        });
-        test('single origin allowlist rejects non-matching https URL', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app';
-            expect(isValid('https://cdn.other.com/a.glb')).toBe(false);
-            expect(isValid('https://attacker.example.com/x')).toBe(false);
-        });
-        test('multi-origin allowlist accepts any listed origin', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app, https://assets.pascal.app';
-            expect(isValid('https://cdn.pascal.app/a.glb')).toBe(true);
-            expect(isValid('https://assets.pascal.app/tex.webp')).toBe(true);
-            expect(isValid('https://third.example.com/x')).toBe(false);
-        });
-        test('allowlist ignores trailing / in URL path (origin match only)', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app';
-            expect(isValid('https://cdn.pascal.app/')).toBe(true);
-            expect(isValid('https://cdn.pascal.app')).toBe(true);
-        });
-        test('empty allowlist behaves like unset', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = '';
-            expect(isValid('https://cdn.other.com/a.glb')).toBe(true);
-        });
-        test('allowlist does not restrict non-https schemes', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app';
-            // these should still pass because they match earlier scheme-based branches
-            expect(isValid('asset://x')).toBe(true);
-            expect(isValid('blob:https://example.com/abc')).toBe(true);
-            expect(isValid('data:image/png;base64,AAA')).toBe(true);
-            expect(isValid('/public/a.glb')).toBe(true);
-            expect(isValid('http://localhost:3000/x')).toBe(true);
-        });
-        test('allowlist rejects subdomain spoofing', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app';
-            expect(isValid('https://cdn.pascal.app.evil.com/x')).toBe(false);
-            expect(isValid('https://evil.com/cdn.pascal.app')).toBe(false);
-        });
-        test('allowlist respects ports', () => {
-            if (!g.process?.env)
-                return;
-            g.process.env[ALLOWED_ORIGINS_ENV] = 'https://cdn.pascal.app:8443';
-            expect(isValid('https://cdn.pascal.app:8443/x')).toBe(true);
-            expect(isValid('https://cdn.pascal.app/x')).toBe(false);
-        });
-    });
-});

package/dist/schema/material.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=material.test.d.ts.map

package/dist/schema/material.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material.test.d.ts","sourceRoot":"","sources":["../../src/schema/material.test.ts"],"names":[],"mappings":""}

package/dist/schema/material.test.js

@@ -1,43 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { MaterialSchema } from './material';
-describe('MaterialSchema', () => {
-    describe('preset', () => {
-        test('valid preset passes through unchanged', () => {
-            const result = MaterialSchema.parse({ preset: 'brick' });
-            expect(result.preset).toBe('brick');
-        });
-        test('every enum preset is accepted', () => {
-            const presets = [
-                'white',
-                'brick',
-                'concrete',
-                'wood',
-                'glass',
-                'metal',
-                'plaster',
-                'tile',
-                'marble',
-                'custom',
-            ];
-            for (const preset of presets) {
-                expect(MaterialSchema.parse({ preset }).preset).toBe(preset);
-            }
-        });
-        test("unknown preset coerces to 'custom' instead of throwing (Sentry MONOREPO-EDITOR-DB)", () => {
-            const result = MaterialSchema.parse({ preset: 'stone' });
-            expect(result.preset).toBe('custom');
-        });
-        test("non-string preset coerces to 'custom'", () => {
-            const result = MaterialSchema.parse({ preset: 42 });
-            expect(result.preset).toBe('custom');
-        });
-        test('missing preset stays undefined', () => {
-            const result = MaterialSchema.parse({});
-            expect(result.preset).toBeUndefined();
-        });
-        test('explicit undefined preset stays undefined', () => {
-            const result = MaterialSchema.parse({ preset: undefined });
-            expect(result.preset).toBeUndefined();
-        });
-    });
-});

package/dist/schema/nodes/measurement.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=measurement.test.d.ts.map

package/dist/schema/nodes/measurement.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"measurement.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/measurement.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/measurement.test.js

@@ -1,139 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { MeasurementNode } from './measurement';
-const parseMeasurement = (measurement) => MeasurementNode.safeParse({
-    id: 'measurement_test',
-    type: 'measurement',
-    measurement,
-});
-describe('MeasurementNode', () => {
-    test('accepts exactly two finite distance points', () => {
-        expect(parseMeasurement({
-            kind: 'distance',
-            points: [
-                [0, 1, 2],
-                [3, 4, 5],
-            ],
-        }).success).toBe(true);
-        expect(parseMeasurement({
-            kind: 'distance',
-            points: [
-                [0, 1, 2],
-                [3, 4, 5],
-                [6, 7, 8],
-            ],
-        }).success).toBe(false);
-        expect(parseMeasurement({
-            kind: 'distance',
-            points: [
-                [0, 1, 2],
-                [Number.POSITIVE_INFINITY, 4, 5],
-            ],
-        }).success).toBe(false);
-    });
-    test('accepts semantic feature anchors with finite fallbacks', () => {
-        expect(parseMeasurement({
-            kind: 'distance',
-            points: [
-                {
-                    kind: 'feature',
-                    reference: {
-                        nodeId: 'wall_a',
-                        featureId: 'wall:centerline',
-                        parameters: { t: 0.25, side: 'center' },
-                    },
-                    fallback: [1, 0, 2],
-                },
-                [3, 0, 2],
-            ],
-        }).success).toBe(true);
-    });
-    test('accepts angle and perimeter measurements', () => {
-        expect(parseMeasurement({
-            kind: 'angle',
-            points: [
-                [1, 0, 0],
-                [0, 0, 0],
-                [0, 0, 1],
-            ],
-        }).success).toBe(true);
-        expect(parseMeasurement({
-            kind: 'perimeter',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 1],
-            ],
-        }).success).toBe(true);
-    });
-    test('requires at least three area base points', () => {
-        expect(parseMeasurement({
-            kind: 'area',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 1],
-            ],
-        }).success).toBe(true);
-        expect(parseMeasurement({
-            kind: 'area',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-            ],
-        }).success).toBe(false);
-        expect(parseMeasurement({
-            kind: 'area',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [2, 0, 0],
-            ],
-        }).success).toBe(false);
-        expect(parseMeasurement({
-            kind: 'area',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [1, 0, 1],
-                [0, 0.1, 1],
-            ],
-        }).success).toBe(false);
-    });
-    test('requires a finite extrusion and at least three volume base points', () => {
-        expect(parseMeasurement({
-            kind: 'volume',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 1],
-            ],
-            extrusion: [0, 2, 0],
-        }).success).toBe(true);
-        expect(parseMeasurement({
-            kind: 'volume',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-            ],
-            extrusion: [0, 2, 0],
-        }).success).toBe(false);
-        expect(parseMeasurement({
-            kind: 'volume',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 1],
-            ],
-            extrusion: [0, Number.NaN, 0],
-        }).success).toBe(false);
-        expect(parseMeasurement({
-            kind: 'volume',
-            base: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [0, 0, 1],
-            ],
-            extrusion: [2, 0, 0],
-        }).success).toBe(false);
-    });
-});

package/dist/schema/nodes/ridge-vent-defaults.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ridge-vent-defaults.test.d.ts.map

package/dist/schema/nodes/ridge-vent-defaults.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ridge-vent-defaults.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/ridge-vent-defaults.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/ridge-vent-defaults.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { createDefaultRidgeVentsForSegment, getRidgeVentLinesForSegment, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, RidgeVentNode, } from './ridge-vent';
-import { getDutchRoofMetrics, getRoofSegmentVisibleTopBounds, ROOF_SHAPE_DEFAULTS, RoofSegmentNode, } from './roof-segment';
-describe('createDefaultRidgeVentsForSegment', () => {
-    test('creates one shingled default ridge vent for gable roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'gable',
-            width: 8,
-            depth: 6,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents).toHaveLength(1);
-        expect(vents[0]?.name).toBe('Ridge Vent');
-        expect(vents[0]?.style).toBe('shingled');
-        expect(vents[0]?.roofSegmentId).toBe(segment.id);
-        expect(isDefaultRidgeVentNode(vents[0], segment.id)).toBe(true);
-    });
-    test('keeps generated gable ridge vents anchored to the untrimmed ridge', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'gable',
-            width: 8,
-            depth: 6,
-            overhang: 0,
-            wallThickness: 0,
-            shingleThickness: 0,
-            trim: { left: 1, right: 2, front: 0, back: 0 },
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents).toHaveLength(1);
-        expect(vents[0]?.length).toBeCloseTo(8);
-        expect(vents[0]?.position[0]).toBeCloseTo(0);
-    });
-    test('creates top ridge plus four hip vents for rectangular hip roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'hip',
-            width: 8,
-            depth: 6,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents).toHaveLength(5);
-        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
-        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
-        for (const vent of vents) {
-            expect(vent.style).toBe('shingled');
-            expect(vent.length).toBeGreaterThan(0.4);
-            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
-        }
-    });
-    test('omits the collapsed top ridge on square hip roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'hip',
-            width: 6,
-            depth: 6,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents).toHaveLength(4);
-        expect(vents.every((vent) => vent.name === 'Hip Ridge Vent')).toBe(true);
-    });
-    test('creates a top ridge plus four hip vents for width-axis Dutch roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'dutch',
-            width: 8,
-            depth: 6,
-            overhang: 0,
-            wallThickness: 0,
-            shingleThickness: 0,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
-        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
-        // Width-axis Dutch ridge runs along X (constant Z = 0).
-        const metrics = getDutchRoofMetrics(segment);
-        const ridge = vents.find((vent) => vent.name === 'Ridge Vent');
-        const frontRightHip = vents.find((vent) => vent.name === 'Hip Ridge Vent' &&
-            (vent.position[0] ?? 0) > 0 &&
-            (vent.position[2] ?? 0) > 0);
-        const expectedRakeReach = Math.min(segment.dutchGabletRake, Math.max(0, segment.width / 2 - metrics.waistHalfX) * 0.98);
-        expect(ridge?.position[2]).toBeCloseTo(0);
-        expect(ridge?.length).toBeCloseTo((metrics.waistHalfX + expectedRakeReach) * 2, 2);
-        expect(frontRightHip?.position[0]).toBeCloseTo((4 + 2.93) / 2, 2);
-        expect(frontRightHip?.position[2]).toBeCloseTo((3 + 1.5) / 2, 2);
-        for (const vent of vents) {
-            expect(vent.style).toBe('shingled');
-            expect(vent.length).toBeGreaterThan(0.4);
-            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
-        }
-    });
-    test('treats legacy segments with generated ridge vents as auto-enabled', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'gable',
-            width: 8,
-            depth: 6,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        const nodes = Object.fromEntries(vents.map((vent) => [vent.id, vent]));
-        expect(isAutoRidgeVentEnabled({
-            id: segment.id,
-            children: vents.map((vent) => vent.id),
-            metadata: {},
-        }, nodes)).toBe(true);
-    });
-    test('treats legacy preset-white ridge vents as generated defaults', () => {
-        const segment = RoofSegmentNode.parse({
-            id: 'rseg_test',
-            roofType: 'gable',
-            width: 8,
-            depth: 6,
-        });
-        const legacyVent = RidgeVentNode.parse({
-            id: 'rvent_legacy',
-            roofSegmentId: segment.id,
-            name: 'Ridge Vent',
-            style: 'shingled',
-            materialPreset: 'preset-white',
-            position: [0, 0, 0],
-            length: 8,
-        });
-        expect(isDefaultRidgeVentNode(legacyVent, segment.id)).toBe(true);
-    });
-    test('creates a Z-oriented ridge plus four hip lines for depth-axis Dutch roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'dutch',
-            width: 6,
-            depth: 8,
-            overhang: 0,
-            wallThickness: 0,
-            shingleThickness: 0,
-        });
-        const lines = getRidgeVentLinesForSegment(segment);
-        const metrics = getDutchRoofMetrics(segment);
-        const expectedRakeReach = Math.min(segment.dutchGabletRake, Math.max(0, segment.depth / 2 - metrics.waistHalfZ) * 0.98);
-        const ridges = lines.filter((line) => line.name === 'Ridge Vent');
-        const hips = lines.filter((line) => line.name === 'Hip Ridge Vent');
-        expect(ridges).toHaveLength(1);
-        expect(hips).toHaveLength(4);
-        // Depth-axis Dutch ridge runs along Z (constant X = 0).
-        expect(ridges[0]?.start[0]).toBeCloseTo(0);
-        expect(ridges[0]?.end[0]).toBeCloseTo(0);
-        expect(Math.abs(ridges[0]?.start[1] ?? 0)).toBeCloseTo(metrics.waistHalfZ + expectedRakeReach, 2);
-    });
-    test('keeps Dutch hip lines on the rendered arris when the roof has overhang', () => {
-        // Overhang + shingle thickness expand the rendered roof; the eave corners
-        // and the waist must share that expanded frame, otherwise the hip lines
-        // tilt off the arris and the vents sink into the slope.
-        const segment = RoofSegmentNode.parse({
-            roofType: 'dutch',
-            width: 8,
-            depth: 6,
-            overhang: 0.5,
-            wallThickness: 0.2,
-            shingleThickness: 0.05,
-        });
-        const lines = getRidgeVentLinesForSegment(segment);
-        const hips = lines.filter((line) => line.name === 'Hip Ridge Vent');
-        const ridge = lines.find((line) => line.name === 'Ridge Vent');
-        expect(hips).toHaveLength(4);
-        expect(ridge).toBeDefined();
-        const bounds = getRoofSegmentVisibleTopBounds(segment);
-        const { axis, inset } = getDutchRoofMetrics(segment);
-        const waistLengthRatio = segment.dutchWaistLengthRatio;
-        // width 8 >= depth 6 -> axis 'x': the ridge runs along X (waist scaled by
-        // waistLengthRatio), and Z is the clean hipped axis (inset exactly).
-        expect(axis).toBe('x');
-        const halfWExpanded = bounds.maxX;
-        const halfDExpanded = bounds.maxZ;
-        const expectedWaistX = (halfWExpanded - inset) * waistLengthRatio;
-        const expectedWaistZ = halfDExpanded - inset;
-        const expectedRakeReach = Math.min(segment.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake, Math.max(0, halfWExpanded - expectedWaistX) * 0.98);
-        for (const hip of hips) {
-            const [ex, ez] = hip.start;
-            const [wx, wz] = hip.end;
-            // Eave end on an expanded-bounds corner; upper end at the rendered rake
-            // termination where the lower slope starts, derived from the SAME
-            // expanded frame (not the base-dim inner waist).
-            expect(Math.abs(ex)).toBeCloseTo(halfWExpanded);
-            expect(Math.abs(ez)).toBeCloseTo(halfDExpanded);
-            expect(Math.abs(wx)).toBeCloseTo(expectedWaistX + expectedRakeReach);
-            expect(Math.abs(wz)).toBeCloseTo(expectedWaistZ);
-        }
-    });
-    test('creates top ridge plus four upper hip vents plus four lower-slope vents for mansard roofs', () => {
-        const segment = RoofSegmentNode.parse({
-            roofType: 'mansard',
-            width: 8,
-            depth: 6,
-        });
-        const vents = createDefaultRidgeVentsForSegment(segment);
-        expect(vents).toHaveLength(9);
-        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
-        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
-        expect(vents.filter((vent) => vent.name === 'Slope Ridge Vent')).toHaveLength(4);
-        expect(vents.find((vent) => vent.name === 'Ridge Vent')?.length).toBeLessThan(segment.width);
-        const slopeVents = vents.filter((vent) => vent.name === 'Slope Ridge Vent');
-        const slopeRotations = slopeVents.map((vent) => Math.abs(vent.rotation));
-        expect(slopeRotations.every((rotation) => rotation > 0.1)).toBe(true);
-        expect(slopeRotations.every((rotation) => Math.abs(rotation - Math.PI / 2) > 0.1)).toBe(true);
-        expect(slopeVents.every((vent) => Math.abs(vent.position[0]) > segment.width / 2 - 0.8 &&
-            Math.abs(vent.position[2]) > segment.depth / 2 - 0.8)).toBe(true);
-        expect(new Set(slopeVents.map((vent) => `${Math.sign(vent.position[0])},${Math.sign(vent.position[2])}`)).size).toBe(4);
-        for (const vent of vents) {
-            expect(vent.style).toBe('shingled');
-            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
-        }
-    });
-});

package/dist/schema/nodes/roof-segment-shape.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=roof-segment-shape.test.d.ts.map

package/dist/schema/nodes/roof-segment-shape.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"roof-segment-shape.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment-shape.test.ts"],"names":[],"mappings":""}