@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/ifc/ifc_regression_batch_main.js

@@ -44,8 +44,18 @@ async function safeExecWithCancellation(command, timeoutMs) {
         });
         // Set up the timeout promise.
         const timeoutHandle = setTimeout(() => {
-            // Timeout occurred: kill the child process.
-            child.kill();
+            // Timeout occurred: SIGKILL (not the default SIGTERM) so a child stuck
+            // in a wasm compute loop is force-killed. A model exceeding the timeout
+            // is not expected once batch concurrency is bounded — this is a safety
+            // net. The explicit process.exit at the end of the run guarantees the
+            // batch still terminates promptly even if a killed child leaves a
+            // grandchild behind holding an open pipe.
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                // Already gone.
+            }
             resolve({
                 type: 'Failed',
                 name: 'TimeoutError',
@@ -78,6 +88,39 @@ function csvSafeString(from) {
     }
     return from;
 }
+/**
+ * Read back the first field of a line written with csvSafeString.
+ *
+ * Naive `line.split(',')[0]` is wrong for exactly the inputs csvSafeString
+ * exists for: a model filename containing a comma comes back quoted, and
+ * splitting on ',' truncates it mid-name. The zero-geometry collision check
+ * keys on this field, so a truncated name silently changes which stems it
+ * thinks collide.
+ *
+ * @param line A CSV line whose first field was written by csvSafeString.
+ * @return {string} The unescaped first field.
+ */
+function csvFirstField(line) {
+    const trimmed = line.replace(/[\r\n]+$/, '');
+    if (!trimmed.startsWith('"')) {
+        return trimmed.split(',')[0];
+    }
+    let result = '';
+    for (let cursor = 1; cursor < trimmed.length; ++cursor) {
+        if (trimmed[cursor] !== '"') {
+            result += trimmed[cursor];
+            continue;
+        }
+        // A doubled quote is a literal one; a lone quote closes the field.
+        if (trimmed[cursor + 1] === '"') {
+            result += '"';
+            ++cursor;
+            continue;
+        }
+        break;
+    }
+    return result;
+}
 /**
  * Encapsulates a string in a CSV safe way, taking
  * file paths (assumed by directory characters / and \,
@@ -196,6 +239,36 @@ async function runForFile(filePath, outputPath, maxTimeout, perfPath) {
         './compiled/src/ifc/ifc_regression_main.js';
     const safeExecCommand = `node --experimental-specifier-resolution=node ${childScript} -d${perfFlag} "${filePath}" "${outputPath}"`;
     console.log(`Current File: ${filePath}`);
+    // A model file that is still an unsmudged Git LFS pointer is NOT a model,
+    // and must not reach a child. Both engines parse the 132-byte placeholder
+    // as an empty document and exit 0, so without this it reads as a
+    // successful load of a model with no geometry - and a blessing run commits
+    // that to the baseline, where it stays. It already happened: NEMA 23 and
+    // ISSUE_098 were blessed at zero rows and filed as engine bugs (#477)
+    // before anyone noticed the run had never read them. See #486.
+    //
+    // Checked before the stale-digest removal below, deliberately: a local
+    // checkout that failed to smudge should not also destroy the good
+    // committed digest for that model.
+    if (await isGitLfsPointer(filePath)) {
+        console.error(`::error::"${path.basename(filePath)}" is an unsmudged Git LFS pointer, not a model. ` +
+            `Run \`git lfs pull\` in the models checkout.`);
+        return {
+            type: 'Failed',
+            message: 'Git LFS pointer stub, not a model file',
+            failureReason: 'lfs-pointer-stub',
+            name: 'Error',
+        };
+    }
+    // Remove any stale digest before the child runs. Without this, a child that
+    // dies without writing one leaves the committed baseline CSV in place, the
+    // batch hashes THAT, and the model reports an unchanged hash with no failure
+    // and no zero-geometry row - green, while extraction is completely broken.
+    // That is precisely the case this gate exists to catch.
+    const staleDigest = `${outputPath}.csv`;
+    if (fs.existsSync(staleDigest)) {
+        await fsPromises.rm(staleDigest, { force: true });
+    }
     // Use safeExecWithCancellation, will kill the process if it takes longer than MAX_TIMEOUT_MS.
     const process = await safeExecWithCancellation(safeExecCommand, MAX_TIMEOUT_MS);
     totalTime += Date.now() - startTime;
@@ -218,22 +291,78 @@ async function runForFile(filePath, outputPath, maxTimeout, perfPath) {
     }
     const outputFile = path.basename(outputPath);
     let fileHash;
+    // Absent digest counts as zero geometry: the stale file was removed before
+    // the child ran, so nothing here can be left over from the committed
+    // baseline. A child that dies without writing one is exactly the case this
+    // gate exists to catch, and hashing the old file would report it as green.
+    let producedNoGeometry = true;
     const outputCSV = `${outputPath}.csv`;
     if (fs.existsSync(outputCSV)) {
+        const digest = await fsPromises.readFile(outputCSV);
         fileHash = crypto
             .createHash('sha1')
-            .update(await fsPromises.readFile(outputCSV))
+            .update(digest)
             .digest('hex');
+        // A digest with nothing after its header means the model loaded and
+        // produced no geometry at all. The child still exits 0, so this is
+        // invisible to every other signal the harness has — see #477 / #478.
+        //
+        // Known limitation: a digest row is any hashed entity, and that includes
+        // non-renderable ones (IFCSURFACESTYLE, IFCPOLYLINE, IFCCENTERLINEPROFILEDEF
+        // …), so "has rows" is weaker than "has renderable geometry". A model that
+        // emits only styles and profiles reads as fine here. That is a deliberate
+        // floor, not an oversight: this catches the total-blank case with zero
+        // false positives, which is what an unconditional CI gate needs. Tightening
+        // it to a mesh/vertex count means teaching the digest which types are
+        // renderable and re-blessing every baseline; tracked on #478.
+        producedNoGeometry =
+            digest.toString('utf8').split('\n').filter((line) => line.trim().length > 0).length <= 1;
     }
     return {
         type: 'Run',
         errorLines: errorLines.length > 0 ? errorLines : undefined,
         outputFile,
         hash: fileHash,
+        producedNoGeometry,
     };
 }
 // Model files the regression harness understands: IFC plus STEP AP214.
 const SUPPORTED_MODEL_EXTENSIONS = ['.ifc', '.stp', '.step'];
+/**
+ * First bytes of a Git LFS pointer file, per the v1 pointer spec. The spec
+ * fixes this as the first line of every pointer, so a prefix match is exact
+ * rather than a heuristic - and no STEP or IFC file can begin this way, both
+ * being required to start with `ISO-10303-21;`.
+ */
+const GIT_LFS_POINTER_PREFIX = 'version https://git-lfs.github.com/spec/v1';
+/**
+ * Whether this file is an unsmudged Git LFS pointer rather than the model it
+ * stands for.
+ *
+ * Reads only the prefix: pointers are ~132 bytes, and a real model may be
+ * hundreds of megabytes.
+ *
+ * @param filePath Model file to inspect.
+ * @return {Promise<boolean>} True if the file is an LFS pointer stub.
+ */
+async function isGitLfsPointer(filePath) {
+    let handle;
+    try {
+        handle = await fsPromises.open(filePath, 'r');
+        const buffer = Buffer.alloc(GIT_LFS_POINTER_PREFIX.length);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return bytesRead === buffer.length &&
+            buffer.toString('utf8') === GIT_LFS_POINTER_PREFIX;
+    }
+    catch {
+        // Unreadable is not this function's business to report - let the child
+        // run and fail with whatever the real problem is.
+        return false;
+    }
+    finally {
+        await handle?.close();
+    }
+}
 /**
  * Whether this is a STEP (AP214) model file by extension.
  *
@@ -311,13 +440,15 @@ function getSystemMemoryUsagePercent() {
  * @param errorLines
  * @param fileLines
  * @param failedLines
+ * @param zeroGeometryLines
  * @param memUtilization
  * @param maxTimeout
+ * @param concurrency Max children processed at once (>= 1).
  * @param perfDir If set, the child writes its perf CSV here as <basename>.perf.csv.
  */
-async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout, perfDir) {
-    const concurrencyLimit = os.cpus().length;
-    console.log(`Concurrency: ${concurrencyLimit} threads - Max Timeout: ${maxTimeout} ms`);
+async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, memUtilization, maxTimeout, concurrency, perfDir) {
+    const concurrencyLimit = Math.max(1, concurrency);
+    console.log(`Concurrency: ${concurrencyLimit} children - Max Timeout: ${maxTimeout} ms`);
     const limit = pLimit(concurrencyLimit);
     const taskTimeout = 2000;
     let activeTasks = 0;
@@ -349,12 +480,18 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
             fileLines.push(`${csvSafeString(path.basename(ifcPath))},` +
                 `${csvSafeString(fileResults.hash ?? '')},` +
                 `${fileResults.errorLines?.length ?? 0}\n`);
+            if (fileResults.producedNoGeometry) {
+                zeroGeometryLines.push(`${csvSafeString(path.basename(ifcPath))}\n`);
+            }
         }
         else {
             // it's 'Failed'
+            // failureReason takes the signal column when the harness diagnosed the
+            // failure itself, so the row says what happened instead of leaving a
+            // reader to infer it from two empty fields. See RunErrorResults.
             failedLines.push(`${csvSafeString(path.basename(ifcPath))},` +
                 `${csvSafeString(fileResults.code?.toString() ?? '')},` +
-                `${csvSafeString(fileResults.signal ?? '')}\n`);
+                `${csvSafeString(fileResults.failureReason ?? fileResults.signal ?? '')}\n`);
         }
     }
 }
@@ -367,10 +504,11 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
  * @param errorLines
  * @param fileLines
  * @param failedLines
+ * @param zeroGeometryLines
  * @param maxTimeout
  * @param perfDir If set, the child writes its perf CSV here as <basename>.perf.csv.
  */
-async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfDir) {
+async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfDir) {
     const items = await fsPromises.readdir(parentPath, { withFileTypes: true });
     items.sort((a, b) => (a.name > b.name ? 1 : -1));
     for (const item of items) {
@@ -379,7 +517,7 @@ async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, f
             continue;
         }
         if (item.isDirectory()) {
-            await recursiveWalk(resolved, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfDir);
+            await recursiveWalk(resolved, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfDir);
         }
         else if (isSupportedModelFile(resolved)) {
             const perfChildPath = perfDir ?
@@ -391,9 +529,13 @@ async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, f
                     errorLines.push(...fileResults.errorLines);
                 }
                 fileLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.hash ?? '')},${fileResults.errorLines?.length ?? 0}\n`);
+                if (fileResults.producedNoGeometry) {
+                    zeroGeometryLines.push(`${csvSafeString(path.basename(resolved))}\n`);
+                }
             }
             else {
-                failedLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.code?.toString() ?? '')},${csvSafeString(fileResults.signal ?? '')}\n`);
+                // See the parallel path's copy for why failureReason wins here.
+                failedLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.code?.toString() ?? '')},${csvSafeString(fileResults.failureReason ?? fileResults.signal ?? '')}\n`);
             }
         }
     }
@@ -437,6 +579,17 @@ const args = yargs(process.argv.slice(SKIP_PARAMS))
         alias: 'm',
         default: 95,
     });
+    // only relevant if parallel is enabled
+    yargs2.option('concurrency', {
+        describe: 'Max IFC files processed at once in parallel mode. Each child ' +
+            'is itself multi-threaded, so os.cpus() children heavily ' +
+            'oversubscribe the cores: the largest models\' wall-clock then ' +
+            'balloons (spurious timeouts) and per-model perf numbers become ' +
+            'noise. Lower this for steady timings. Default: CPU core count.',
+        type: 'number',
+        alias: 'j',
+        default: 0,
+    });
     // Validate mem-utilization only if parallel mode is active
     yargs2.check((argv) => {
         if (argv.parallel) {
@@ -481,6 +634,9 @@ const args = yargs(process.argv.slice(SKIP_PARAMS))
     const doParallel = argv['parallel'] ?? false; // <--- read the parallel flag
     const memUtilization = argv['mem-utilization'];
     const maxTimeout = argv['timeout'];
+    // 0 (the default) means "auto": one child per core.
+    const concurrencyArg = argv['concurrency'];
+    const concurrency = concurrencyArg && concurrencyArg > 0 ? Math.floor(concurrencyArg) : os.cpus().length;
     const perfOutputPath = (argv['perf'] ?? '').trim();
     if (changes.length === 0) {
         changes = path.join(outputPath, 'changes');
@@ -498,25 +654,60 @@ const args = yargs(process.argv.slice(SKIP_PARAMS))
     const mainPath = path.join(outputPath, 'main.csv');
     const errorPath = path.join(outputPath, 'errors.csv');
     const failedPath = path.join(outputPath, 'failed.csv');
+    const zeroGeometryPath = path.join(outputPath, 'zero_geometry.csv');
     const errorLines = [];
     const fileLines = [];
     const failedLines = [];
+    const zeroGeometryLines = [];
     const excludeRegex = excludeFilter.length > 0 ? new RegExp(excludeFilter) : undefined;
     if (doParallel) {
         console.log('Processing in parallel mode...');
         // 1) Collect all IFC files first
         const allIFCFiles = await collectIFCFiles(ifcFolder, excludeRegex);
         // 2) Process them in parallel
-        await processIFCFilesInParallel(allIFCFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout, perfTmpDir);
+        await processIFCFilesInParallel(allIFCFiles, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, memUtilization, maxTimeout, concurrency, perfTmpDir);
     }
     else {
         console.log('Processing in serial mode...');
-        await recursiveWalk(ifcFolder, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfTmpDir);
+        await recursiveWalk(ifcFolder, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfTmpDir);
     }
     // Write out results
     await fsPromises.writeFile(mainPath, `file,hash,errors\n${fileLines.join('')}`);
     await fsPromises.writeFile(errorPath, `${errorCSVHeader}\n${errorLines.join('')}`);
     await fsPromises.writeFile(failedPath, `file,code,signal\n${failedLines.join('')}`);
+    // Models that loaded and produced no geometry. Written as its own
+    // artifact rather than folded into failed.csv, because the two need
+    // different gates: failed.csv is empty and stays empty, while a
+    // handful of zero-geometry models are known and tracked (#477), so
+    // CI compares this against an explicit allowlist instead.
+    // Models whose digest stem collides cannot be judged: two models
+    // sharing a basename write the SAME digest file, so in --parallel one
+    // can be read between another's truncate and its first row. That
+    // collision is a pre-existing harness bug (it also means the blessed
+    // digest is whichever model ran last) - `ifc/index.ifc` and
+    // `ifc/bldrs/index.ifc` are a live example, both in the smoke subset.
+    // Suppress rather than guess, so it cannot red an unrelated PR, and
+    // say so loudly.
+    const stemCounts = new Map();
+    for (const line of fileLines) {
+        const stem = path.parse(csvFirstField(line)).name;
+        stemCounts.set(stem, (stemCounts.get(stem) ?? 0) + 1);
+    }
+    const collidingStems = new Set([...stemCounts].filter(([, count]) => count > 1).map(([stem]) => stem));
+    if (collidingStems.size > 0) {
+        console.warn(`WARNING: ${collidingStems.size} digest stem(s) are written by more ` +
+            `than one model, so their digests overwrite each other and their ` +
+            `zero-geometry status cannot be determined: ${[...collidingStems].join(', ')}`);
+    }
+    const reportableZeroGeometry = zeroGeometryLines.filter((line) => !collidingStems.has(path.parse(csvFirstField(line)).name));
+    await fsPromises.writeFile(zeroGeometryPath, `file\n${reportableZeroGeometry.join('')}`);
+    if (reportableZeroGeometry.length > 0) {
+        console.log(`\n${reportableZeroGeometry.length} model(s) loaded but produced NO geometry:`);
+        for (const line of reportableZeroGeometry) {
+            console.log(`  ${line.trim()}`);
+        }
+        console.log('');
+    }
     // Aggregate per-child perf rows (if requested) before runDiff so the
     // run completes deterministically even when the git diff step is
     // skipped or fails.
@@ -539,5 +730,12 @@ const args = yargs(process.argv.slice(SKIP_PARAMS))
     const overallEnd = Date.now();
     const totalSec = ((overallEnd - overallStart) / divisor).toFixed(fixedPoint);
     console.log(`\nAll tasks completed. Total runtime: ${totalSec} seconds.`);
+    // All work is done and every CSV is written. Exit explicitly rather
+    // than waiting for the event loop to drain: a child that had to be
+    // force-killed (or any lingering wasm worker handle) can otherwise
+    // keep this process alive long after the run, hanging the CI step
+    // for the rest of the job timeout. console.log to a pipe is
+    // synchronous on Linux, so the line above is already flushed.
+    process.exit(0);
 })
     .help().argv;

package/compiled/src/ifc/ifc_spatial_skeleton.d.ts

@@ -0,0 +1,145 @@
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import { StreamingRecordDispatcher } from "../step/parsing/streaming_record_dispatcher.js";
+/** One node of the skeleton: what a tree row needs, and nothing else. */
+export interface SkeletonNode {
+    /** The record's express ID. */
+    expressID: number;
+    /** The record's concrete type. */
+    type: EntityTypesIfc;
+    /** `Name`, when the record carried one. */
+    name?: string;
+    /** `LongName`, for spatial elements that carried one. */
+    longName?: string;
+    /** `GlobalId`, when the record carried one. */
+    globalId?: string;
+    /** Children, in the order their relationships were parsed. */
+    children: SkeletonNode[];
+}
+/**
+ * The spatial **names skeleton** (M2, issue #393): project → site → building →
+ * storey → product, with names, built from the streaming parse's record events
+ * so the tree can be shown while the model is still loading.
+ *
+ * This is the one standard consumer that genuinely belongs on the event path,
+ * and the reason is the record's *bytes*. Everything else M2 wanted —
+ * membership, counts, ids — is in the columnar index and is cheaper (and, for
+ * complex records, only correct) when derived from a prefix snapshot; see
+ * {@link import('../step/parsing/prefix_type_index').PrefixTypeIndex}. Names
+ * and relationship edges are not in the columns, and after the parse they cost
+ * a second pass that pages every relationship and every named record back in
+ * through the windowed provider — which is exactly what Share's post-parse
+ * `'names'` sweep does today.
+ *
+ * What runs per record is deliberately small: tokenize the record's attribute
+ * list, copy out at most three short strings, and append two integers per
+ * edge. Nothing is resolved and no tree is built until {@link tree} is called —
+ * "resolvable" therefore means "present when you asked", and a file that
+ * forward-references its way through the spatial hierarchy simply resolves at
+ * end of stream, with no pending-reference table to maintain.
+ *
+ * Idempotence: the streaming builder's grow-and-restart re-fires records from
+ * localID 0. A non-ascending localID is taken as that restart and clears both
+ * the nodes and the edge columns, so a restarted parse rebuilds rather than
+ * doubling its edges.
+ */
+export declare class IfcSpatialSkeleton {
+    private readonly nodes_;
+    private edgeParents_;
+    private edgeChildren_;
+    private edgeCount_;
+    private readonly cursor_;
+    private lastLocalID_;
+    /**
+     * @param parser The IFC parser whose tokenizer reads the record bytes.
+     * Defaults to the singleton the streaming open uses.
+     */
+    constructor(parser?: IfcStepParser);
+    /**
+     * Subscribe this skeleton to a dispatcher — the object definitions it names
+     * and the two relationship types it draws edges from.
+     *
+     * @param dispatcher The dispatcher fed by the streaming parse.
+     */
+    subscribe(dispatcher: StreamingRecordDispatcher<EntityTypesIfc>): void;
+    /**
+     * @return {number} Nodes seen so far (children not yet linked).
+     */
+    get nodeCount(): number;
+    /**
+     * @return {number} Containment edges captured so far.
+     */
+    get edgeCount(): number;
+    /**
+     * Record a named object definition. Bound for direct use as a subscription.
+     *
+     * @param localID The record's dense local ID.
+     * @param expressID The record's express ID.
+     * @param typeID The record's concrete type.
+     * @param buffer The live parse window holding the record.
+     * @param byteOffset Offset of the record's attribute list in `buffer`.
+     * @param byteLength Length of the attribute list.
+     */
+    private readonly handleObject;
+    /**
+     * Where this type keeps `LongName`, if it has one.
+     *
+     * @param typeID The record's concrete type.
+     * @return {number | undefined} The attribute index, or undefined for types
+     * that carry no `LongName` at all.
+     */
+    private longNameAttribute;
+    /**
+     * Record the containment edges of one relationship. Bound for direct use as
+     * a subscription.
+     *
+     * @param localID The record's dense local ID.
+     * @param expressID The record's express ID.
+     * @param typeID The record's concrete type.
+     * @param buffer The live parse window holding the record.
+     * @param byteOffset Offset of the record's attribute list in `buffer`.
+     * @param byteLength Length of the attribute list.
+     */
+    private readonly handleRelationship;
+    /**
+     * Reset if the parse restarted. localIDs ascend strictly within a run, so a
+     * localID that does not exceed the last one seen means the streaming
+     * builder hit its grow-and-restart valve and is re-firing from 0. Testing
+     * for `localID === 0` would not do: this consumer only sees its subscribed
+     * types, and record 0 is rarely one of them.
+     *
+     * @param localID The record's dense local ID.
+     */
+    private noteRestart;
+    /**
+     * Append one containment edge, growing the columns as needed.
+     *
+     * @param parent Express ID of the containing entity.
+     * @param child Express ID of the contained entity.
+     */
+    private pushEdge;
+    /**
+     * Look one node up without building the tree.
+     *
+     * @param expressID The express ID.
+     * @return {SkeletonNode | undefined} The node, if it has been parsed.
+     */
+    node(expressID: number): SkeletonNode | undefined;
+    /**
+     * Build the tree over everything parsed so far and return its roots — nodes
+     * that are nobody's child. That is the project once it has been seen, plus
+     * whatever a prefix has not reached the parent of yet, plus the object
+     * definitions that genuinely hang outside the spatial hierarchy (type
+     * objects, ungrouped actors); a caller that wants strictly the spatial tree
+     * should walk down from the project's express ID rather than treat every
+     * root as spatial.
+     *
+     * Each call relinks children from the edge columns, so a caller may call it
+     * repeatedly as the parse advances; the returned nodes are the live ones, so
+     * a previously returned tree is not a snapshot.
+     *
+     * @return {SkeletonNode[]} The roots, in parse order.
+     */
+    tree(): SkeletonNode[];
+}
+//# sourceMappingURL=ifc_spatial_skeleton.d.ts.map

package/compiled/src/ifc/ifc_spatial_skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_spatial_skeleton.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_spatial_skeleton.ts"],"names":[],"mappings":"AAEA,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAQ5D,OAAO,aAAa,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAA;AAwCvF,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAE3B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAA;IAEjB,kCAAkC;IAClC,IAAI,EAAE,cAAc,CAAA;IAEpB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,8DAA8D;IAC9D,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,kBAAkB;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IAEzD,OAAO,CAAC,YAAY,CAAmC;IAEvD,OAAO,CAAC,aAAa,CAAmC;IAExD,OAAO,CAAC,UAAU,CAAI;IAEtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAE3D,OAAO,CAAC,YAAY,CAAK;IAEzB;;;OAGG;gBACU,MAAM,GAAE,aAAsC;IAI3D;;;;;OAKG;IACI,SAAS,CAAE,UAAU,EAAE,yBAAyB,CAAC,cAAc,CAAC,GAAI,IAAI;IAM/E;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CA6C5B;IAED;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAoClC;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IASnB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAiBhB;;;;;OAKG;IACI,IAAI,CAAE,SAAS,EAAE,MAAM,GAAI,YAAY,GAAG,SAAS;IAI1D;;;;;;;;;;;;;;OAcG;IACI,IAAI,IAAI,YAAY,EAAE;CAgC9B"}