@omnitron-dev/omnitron 0.2.0 → 0.3.1

package/dist/services/bundle-builder.d.ts

@@ -0,0 +1,490 @@
+/**
+ * Building the bundle the planner describes.
+ *
+ * `local-bundle.ts` decides what travels; this puts it on disk. Kept apart
+ * because the decision is where the mistakes live and the decision is pure —
+ * this half runs `pnpm pack` and writes files, and can only be checked by
+ * doing it.
+ *
+ * The layout:
+ *
+ *     <out>/package.json        root manifest: file: deps + overrides
+ *     <out>/dist/               the built daemon
+ *     <out>/webapp/dist/        the console
+ *     <out>/vendor/*.tgz        every workspace package, packed
+ *     <out>/BUNDLE.json         what this is, and what it was built from
+ *
+ * `node_modules` is deliberately absent. It is the one thing that must NOT
+ * travel: a tree installed here carries `@esbuild/darwin-arm64` and no
+ * `linux-x64`, and the target is the only machine that knows what it is.
+ */
+import { type BundlePlan, type PackageManifest, type Workspace } from './local-bundle.js';
+/** What a built bundle says about itself. */
+export interface BundleMetadata {
+    /** `0.2.0+local.<sha>.<stamp>` — see `localVersion`. */
+    readonly version: string;
+    /** The commit the tree was on. */
+    readonly commit: string;
+    /** Whether that tree had uncommitted changes. */
+    readonly dirty: boolean;
+    readonly builtAt: string;
+    /** Packages that travelled, for a reader deciding whether to trust it. */
+    readonly vendored: readonly string[];
+}
+export interface BuildBundleOptions {
+    /** Repository root — where the workspace packages live. */
+    readonly workspaceRoot: string;
+    /** Package to bundle. */
+    readonly rootPackage: string;
+    /** Directory to build into. Created; must not already hold a bundle. */
+    readonly outDir: string;
+    /** Files and directories to copy from the package, relative to it. */
+    readonly include?: readonly string[];
+    /**
+     * What each workspace package's sources hashed to in this run, by directory.
+     *
+     * Six apps of one stack vendor the same nineteen omnitron packages, and
+     * hashing each of them six times is six times the work for a tree that
+     * cannot have changed between the first app and the last. Only the reading
+     * is memoised here; the packed tarballs are kept by content in
+     * `packedCachePath`, which is what makes a package that did not change
+     * contribute the identical file to the next bundle.
+     */
+    readonly packCache?: Map<string, string>;
+    /**
+     * Further workspace roots whose packages may be vendored.
+     *
+     * Left out, the packages this one can reach are its own repository's. An
+     * app that depends on a sibling checkout through `link:` needs that
+     * checkout's root here, or the plan refuses it as missing.
+     */
+    readonly additionalWorkspaceRoots?: readonly string[];
+    readonly logger?: {
+        info(msg: string): void;
+    } | undefined;
+}
+export interface BuildBundleResult {
+    readonly outDir: string;
+    readonly metadata: BundleMetadata;
+    readonly plan: BundlePlan;
+}
+/**
+ * Find the repository root from a directory inside it.
+ *
+ * `process.cwd()` is where the operator was standing, and for a command run
+ * from `apps/omnitron` that is two levels below the packages it needs to
+ * bundle. Measured: `fleet upgrade` from the package directory reported
+ * "@omnitron-dev/omnitron is not a package in this workspace" — true of the
+ * directory it was given, and useless about the mistake.
+ *
+ * `pnpm-workspace.yaml` is the marker, because it is what defines the
+ * workspace this file reads. Null rather than a guess when there is none.
+ */
+export declare function findWorkspaceRoot(from: string): string | null;
+/**
+ * Why `fleet upgrade` must not build from here — or null.
+ *
+ * Three refusals, each naming the place rather than a package. No workspace
+ * above the directory. A workspace, but somebody else's: run from
+ * `~/projects/examples/sample`, the command found sample's root and failed inside the
+ * bundler with «@omnitron-dev/omnitron is not a package in this workspace»,
+ * which reads as a broken omnitron checkout (`planBundle` keeps that refusal
+ * for callers that arrive some other way). And a tree with uncommitted
+ * changes: the version a node reports names the commit, so a bundle built
+ * from a dirty tree is a node reporting a commit that is not what it runs —
+ * the record that outlives everyone who knew. That one is lifted only by
+ * `--allow-dirty`, as for `stack start`.
+ */
+export declare function upgradeWorkspaceRefusal(input: {
+    cwd: string;
+    root: string | null;
+    hasOmnitron: boolean;
+    dirty: boolean;
+    allowDirty: boolean;
+}): string | null;
+/**
+ * Read every workspace package's manifest.
+ *
+ * The root is resolved to an absolute path first, and every directory
+ * recorded below is absolute too. `pnpm --dir` resolves a relative path
+ * against ITS OWN working directory, not against the caller's — so a
+ * `workspaceRoot` of `../..` produced `/Users/taaliman/projects/luxquant/
+ * packages`, two levels above where it meant, and the error named a
+ * directory nobody had written down. Paths that cross a process boundary are
+ * absolute.
+ */
+/**
+ * Read several workspace roots into one map.
+ *
+ * An app can depend on packages of another checkout — sample declares every
+ * omni package as `link:/Users/…/omni/packages/<name>` — and a planner given
+ * only the app's own workspace refuses those as missing, which is true of
+ * that workspace and useless about the artifact.
+ *
+ * Earlier roots win a name collision: the first root is the one whose package
+ * is being built, and a package it defines is the one it meant.
+ */
+export declare function readWorkspaces(roots: readonly string[]): Workspace;
+/**
+ * Every workspace root a manifest's `link:` dependencies are INSTALLED from.
+ *
+ * Asked of the installed tree first — `<packageDir>/node_modules/<name>` is
+ * the link pnpm made, and it is what the package's code actually loads — and
+ * of the declared range only when nothing is installed. The two differ where
+ * it matters: sample declares every omni package as an ABSOLUTE
+ * `link:/Users/…/omni/…`, while its lockfile records them relative, and a
+ * release is built in a layout where the relative links land on a clean
+ * clone of omni (`release/layout.ts`). Reading the declaration, the release
+ * builder's packer found the DEVELOPER'S omni instead: on 2026-09-22 both
+ * releases of the day vendored `@omnitron-dev/omnitron` from the working tree
+ * — «rebuilding @omnitron-dev/omnitron — src/services/node-upgrade.service.ts
+ * is newer than anything in dist», a file edited after the clone was made —
+ * and rebuilt the running daemon's own `dist` in passing, uncommitted edits
+ * of other sessions included. The install had been checked to resolve inside
+ * the clone (98 of 98 links); the packer never asked it.
+ *
+ * A relative range is resolved against the package's directory, as pnpm
+ * resolves it — not against whatever directory this process runs in.
+ */
+export declare function linkedWorkspaceRoots(manifest: PackageManifest, packageDir?: string): string[];
+export declare function readWorkspace(workspaceRootInput: string): Workspace;
+/**
+ * Where a packed workspace package is kept, named by what is in it.
+ *
+ * The version is in the name because two versions of one package are two
+ * packages; the content hash is in it because during development a version
+ * stands still for weeks while the code under it moves, and a cache keyed on
+ * the version alone would hand a deployment last week's package under this
+ * week's number. Nothing has to be invalidated: a package that changed has a
+ * different name here and is packed.
+ */
+export declare function packedCachePath(cacheRoot: string, name: string, version: string, contentHash: string): string;
+/**
+ * Remove every incremental-build record a package keeps.
+ *
+ * `tsc` trusts `tsBuildInfoFile`: if the inputs have not changed since that
+ * record was written, it emits nothing and exits zero. The record is written
+ * by whatever machine last built, and a `build` script of `rm -rf dist && tsc`
+ * removes the OUTPUT while leaving the record saying the output is current —
+ * so the build succeeds and `dist` stays exactly as stale as it was.
+ *
+ * Measured on `@sample/bitcoin-rpc`: `src/errors.ts` dated 2026-09-16,
+ * `dist/errors.js` dated 2026-09-10, and `pnpm build` leaving it at
+ * 2026-09-10. Six days of source changes that the build refused to emit,
+ * silently, with a zero exit code — which is why the staleness guard above
+ * has to re-check AFTER building rather than trusting the build.
+ *
+ * Every spelling, because the path is a per-package choice: the root, `dist`,
+ * and `node_modules/.tmp`, which is where a `tsconfig.build.json` in this
+ * workspace tends to put it.
+ */
+export declare function clearBuildInfo(packageDir: string): void;
+/**
+ * Whether a built frontend is older than the sources it was built from.
+ *
+ * The gateway serves `apps/portal/dist` and the deployment ships it exactly
+ * as it finds it. Measured on the test stack: the `index.html` on the node
+ * was built on 2026-09-10 and **879 source files were newer than it** — so
+ * the "test portal", the thing the whole deployment exists to put in front of
+ * someone, was ten days behind the tree it was supposedly testing. Nothing
+ * said so, because nothing looked.
+ *
+ * Same reasoning as `staleDist` and a different shape: a frontend has no
+ * manifest pointing at its output, so the caller names both directories.
+ *
+ * **A frontend's sources are not all under its own `src`.** The portal
+ * resolves several workspace packages from source through Vite aliases, two
+ * of them in a DIFFERENT repository (`@omnitron-dev/prism`,
+ * `@omnitron-dev/netron-browser`), so a change confined to the design system
+ * left `apps/portal/src` untouched, this check said «current», and the
+ * deployment shipped yesterday's bundle. Measured 2026-09-21: all ten «behind
+ * its sources» entries in the daemon log name files under `apps/portal/src`,
+ * not one came from prism, while prism changed on several of those days.
+ *
+ * So the sources are the frontend's own `src` PLUS the `src` of every
+ * dependency that resolves outside `node_modules` — which is what a workspace
+ * link is. Under pnpm every dependency is a symlink (57 of 57 for the
+ * portal), so the symlink itself says nothing; the real path does, and seven
+ * of the portal's dependencies live outside `node_modules`.
+ *
+ * The answer names the directories it watched, because the caller logs it:
+ * a reader must be able to tell «no linked sources» from «never looked».
+ *
+ * **Every linked package counts, even one the frontend imports only for its
+ * types.** Measured on the portal: of its seven, `@sample/geo` is type-only (3
+ * imports, all `import type`) and contributes nothing to the bundle, so
+ * watching it can cost a rebuild nobody needed. Telling types from values
+ * statically is an import-parsing heuristic, and the same counting done twice
+ * here gave 47 value-imports and then 8 — the difference being multi-line
+ * `import type {` blocks whose closing line looks like a value import. The
+ * asymmetry decides it: a false rebuild costs a couple of minutes of CPU, a
+ * missed one puts yesterday's portal in front of a person.
+ */
+export declare function staleBuild(srcDir: string, buildDir: string): string | null;
+/**
+ * The `src` of every dependency that lives outside `node_modules`.
+ *
+ * That is what a workspace link is, and it is the only reliable tell: pnpm
+ * makes EVERY dependency a symlink into its store, so `isSymbolicLink()`
+ * matches all of them. What separates a package being developed here from one
+ * that was installed is where the link lands.
+ *
+ * A package without a `src/` contributes nothing to look at and is skipped,
+ * which also drops anything vendored as built output.
+ */
+/**
+ * The `src` of every dependency that resolves to a working package rather
+ * than an installed copy — what this bundle is actually built FROM.
+ *
+ * Exported because two questions need the same answer and neither may
+ * re-derive it: whether the build is stale, and whether the trees it reads
+ * are the commits they claim.
+ */
+export declare function linkedSourceDirs(pkgDir: string): string[];
+/**
+ * Whether a package's shipped `dist` is older than its sources.
+ *
+ * Only asked of packages that actually ship one — a package whose manifest
+ * points at `src` is consumed as TypeScript by whatever transpiles it, and
+ * has no `dist` to be stale. `publishConfig` is consulted because that is
+ * what `pnpm pack` applies, so the question is about the file the TARBALL
+ * will name, not the one this working tree uses.
+ *
+ * Returns a sentence naming the newest source file, or null when there is
+ * nothing to say — the message is the useful part, since "rebuild it" is
+ * only actionable once you know which package and why.
+ */
+export declare function staleDist(packageDir: string): string | null;
+/** `git rev-parse HEAD` and whether the tree is clean. */
+export declare function describeTree(cwd: string): Promise<{
+    commit: string;
+    dirty: boolean;
+}>;
+/**
+ * Build the bundle.
+ *
+ * Packs into a temporary sibling and renames at the end, so `<out>` either
+ * does not exist or holds a complete bundle. A half-built one is worse than
+ * none: the transfer step has no way to tell it from a finished one, and the
+ * failure lands on the node.
+ */
+export declare function buildBundle(options: BuildBundleOptions): Promise<BuildBundleResult>;
+/**
+ * Tar a built bundle for transfer.
+ *
+ * `-C <dir> .` so the archive holds the bundle's contents at its root rather
+ * than a directory named after wherever it was built. The unpack step extracts
+ * into a version directory it chose; an archive carrying its own top-level
+ * name would put everything one level deeper, and every path after that —
+ * `dist/cli/omnitron.js`, the symlinks, the install — would be wrong by one
+ * segment.
+ */
+/** The file a bundle carries about its own making. */
+export declare const BUNDLE_METADATA_FILE = "BUNDLE.json";
+/**
+ * The record of the packing, which is not part of what was packed.
+ *
+ * It carries `builtAt` and a version stamped from the clock, so a bundle
+ * that includes it in its identity is a different bundle every time it is
+ * built. What it says about the commit and the vendored packages is a
+ * statement about the build, and the files those produced are hashed on
+ * their own account.
+ */
+export declare const isBuildRecord: (relativePath: string) => boolean;
+/**
+ * The name a build gave itself, which is not part of what it built.
+ *
+ * `localVersion` stamps the minute of the build into the bundle's root
+ * manifest — `0.2.0+local.<sha>.202609201755` — so that a node can say which
+ * of two builds of one commit it is running. It is also the one thing in a
+ * bundle that cannot be the same twice, and comparing bundles with it in
+ * hand says "different" about two builds of an untouched tree. Everything
+ * else in that manifest decides what gets installed and is compared.
+ *
+ * Only the bundle's own manifest: a `package.json` below it belongs to a
+ * package that travels, and its version is that package's.
+ */
+export declare const withoutBuildVersion: {
+    appliesTo: (relativePath: string) => boolean;
+    to: (bytes: Buffer) => Buffer;
+};
+export declare const withoutBuildOutput: (relativePath: string) => boolean;
+/**
+ * Installed dependencies, which are not sources and are not packed.
+ *
+ * Matched on the whole last segment: `node_modules_shim.ts` is a source file.
+ */
+export declare const withoutNodeModules: (relativePath: string) => boolean;
+/**
+ * What a bundle IS, independent of when it was packed.
+ *
+ * The archive cannot answer this. `tar -czf` writes the compression time
+ * into the gzip header and every file's own mtime into its entry, and a
+ * bundle is assembled into a fresh staging tree on each build, so two packs
+ * of byte-identical sources are two different files. A deployment that asks
+ * "does the node already have this?" by comparing archive hashes is asking
+ * what time it is.
+ *
+ * So the identity is read from the tree that will travel: every path under
+ * it, sorted, each with the bytes at that path, whether it may be executed,
+ * and — for a symlink — where it points, which is read rather than followed.
+ * Nothing here is a property of this machine or this minute.
+ *
+ * Framed with NULs and lengths so that no rearrangement of names and bodies
+ * can produce the same stream as a different tree.
+ */
+export declare function bundleChecksum(bundleDir: string, options?: {
+    readonly skip?: (relativePath: string) => boolean;
+    /** A file to hash as something other than its bytes — see `withoutBuildVersion`. */
+    readonly rewrite?: {
+        appliesTo(relativePath: string): boolean;
+        to(bytes: Buffer): Buffer;
+    };
+}): Promise<string>;
+export declare function archiveBundle(bundleDir: string, archivePath: string): Promise<string>;
+/** The package omnitron itself is — what a node's own upgrade is built from. */
+export declare const OMNITRON_PACKAGE = "@omnitron-dev/omnitron";
+/**
+ * Where one build of omnitron's own bundle is staged.
+ *
+ * Under the temporary directory and named by the caller's label, so that the
+ * console upgrading one node and a `fleet upgrade` running in a terminal
+ * never stage into each other's directory.
+ */
+export declare function ownBundleStaging(label: string): string;
+/** A built bundle of omnitron itself, ready to be packed and installed. */
+export interface OwnBundle {
+    /** `0.2.0+local.<sha>.<stamp>` — what the node will report once it runs this. */
+    readonly version: string;
+    /** Whether the tree it was built from had uncommitted changes. */
+    readonly dirty: boolean;
+    /** Pack it for transfer. The same archive, however often this is called. */
+    pack(): Promise<string>;
+    /** Remove the staging tree and the archive. Safe to call more than once. */
+    cleanup(): Promise<void>;
+}
+/**
+ * Why omnitron's own build may not travel under the tree's commit — or null.
+ *
+ * The bundle copies `dist` and `webapp/dist` as they are on disk and names
+ * itself after the working tree's HEAD, and nothing compared the two.
+ * Measured 2026-09-23: a node installed as `0.2.0+local.f1715106…` received a
+ * console build older than f1715106, whose only change was that console. A
+ * `dist` compiled before the last commit ships the code before it under the
+ * commit's name, and the node's version is the record everyone reads
+ * afterwards. Each build now carries its own stamp (`BUILD.json`, written by
+ * `scripts/stamp-build.mjs`), and it must name the commit the tree is on,
+ * from a clean tree.
+ */
+export declare function ownBuildRefusal(input: {
+    packageDir: string;
+    tree: {
+        commit: string;
+        dirty: boolean;
+    };
+}): string | null;
+/**
+ * Build omnitron from a working tree, for installing on a node.
+ *
+ * Two callers do this — `omnitron fleet upgrade` from a terminal, and the
+ * daemon when the console asks — and each used to write it out: the package
+ * name, the staging path, the `buildBundle`/`archiveBundle` pair. The copies
+ * had already drifted, in the way copies do: the daemon removed its staging
+ * tree in a `finally`, and the CLI left several hundred megabytes in the
+ * temporary directory on every run, including every `--dry-run` that shipped
+ * nothing at all.
+ *
+ * Packing is separate from building because a dry run wants the version and
+ * not the tarball.
+ */
+export declare function buildOwnBundle(options: {
+    readonly workspaceRoot: string;
+    /** What distinguishes this build's staging directory from another's. */
+    readonly label: string;
+    readonly logger?: {
+        info(message: string): void;
+    };
+}): Promise<OwnBundle>;
+/**
+ * Everything that decides what an application's compiler emits.
+ *
+ * The application's own sources, and every workspace package that travels
+ * with it — the same closure the bundle vendors, because a package whose
+ * code moved changes both what the app compiles against and what ships
+ * beside it. A dependency is read whole, sources and `dist` together: which
+ * of the two moved is not the question, only whether anything did.
+ *
+ * `null` for every answer that cannot be had — no workspace above the app, a
+ * manifest that will not parse, a plan that refuses. The caller compiles.
+ *
+ * `memo` is shared with the packing step, which asks the same question of
+ * the same directories; `buildBundle` drops an entry for any package it
+ * rebuilds, so nothing here outlives the state it measured.
+ */
+export declare function buildInputsChecksum(appDir: string, options?: {
+    readonly additionalWorkspaceRoots?: readonly string[];
+    readonly memo?: Map<string, string>;
+}): Promise<string | null>;
+/**
+ * Where a bundle lands, and how a version becomes the live one.
+ *
+ *     <prefix>/versions/<version>/     one unpacked bundle, one version
+ *     <prefix>/current   →  versions/<version>     a symlink
+ *     <prefix>/bin/omnitron  →  current/dist/cli/omnitron.js
+ *
+ * The indirection is what makes an upgrade reversible. A version is unpacked
+ * and installed BESIDE the running one, verified there, and only then does
+ * `current` move — one `ln -sfn`, which `rename(2)` makes atomic. Nothing is
+ * ever half-installed over the copy that is serving, and going back is the
+ * same one command pointed at the previous directory.
+ *
+ * Installing in place is the alternative, and it fails in the way that costs
+ * most: an `npm install` that dies halfway has already replaced some of
+ * `node_modules`, so the daemon that was working is now a daemon that cannot
+ * start, on a machine somewhere else.
+ */
+export interface InstallLayout {
+    readonly prefix: string;
+    readonly version: string;
+}
+export declare function versionDir(layout: InstallLayout): string;
+export interface RemoteStep {
+    readonly what: string;
+    readonly command: string;
+    readonly timeoutMs: number;
+}
+/** Check physical ownership before even uploading into the prefix. */
+export declare function installPreflightCommand(layout: InstallLayout): string;
+/**
+ * A completed version is never unpacked or installed again. Each attempt gets
+ * a fresh sibling and publishes it only after npm and the actual CLI pass.
+ * The receipt hashes the complete installed tree, so reuse verifies both the
+ * archive identity and physical dependencies, including modes and symlinks.
+ * Failed siblings remain available for diagnosis; they are never reused.
+ */
+export declare function installSteps(layout: InstallLayout, archivePath: string, expectedArchiveSha256?: string): readonly RemoteStep[];
+/**
+ * Make an installed version the live one.
+ *
+ * Separate from `installSteps` because this is the only step that changes
+ * what runs, and a caller that stopped before it has changed nothing.
+ */
+export declare function activateSteps(layout: InstallLayout, pathDir?: string): readonly RemoteStep[];
+/**
+ * Keep the last `keep` versions and remove the rest.
+ *
+ * «Last» by the build stamp that ends every local version —
+ * `0.2.0+local.<sha>.<stamp>` — not by the name. The name was the sort key,
+ * on the stated ground that it «is chronological»; it is not, because the
+ * sha comes first. On sample/test (2026-09-25) three upgrades in one morning
+ * left the node with the running version and three from 22–23 September,
+ * and deleted 311bddb1 and de454a80 — the two a rollback would have wanted.
+ * A version without a numeric stamp counts as the oldest.
+ *
+ * `current` is never removed whatever its age: a retention that reasons
+ * about age must not be the thing that deletes what is running. Portable
+ * `awk` rather than GNU `head -n -N`, so the court can run the command
+ * itself on the machine that builds.
+ */
+export declare function pruneSteps(layout: InstallLayout, keep: number, protectedRoots?: readonly string[]): readonly RemoteStep[];
+//# sourceMappingURL=bundle-builder.d.ts.map

package/dist/services/bundle-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-builder.d.ts","sourceRoot":"","sources":["../../src/services/bundle-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAWH,OAAO,EAML,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAI3B,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yBAAyB;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,SAAS,CAAC;CAC3D;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB,GAAG,MAAM,GAAG,IAAI,CAiBhB;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAQlE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB7F;AAED,wBAAgB,aAAa,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAsBnE;AAgBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAG7G;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CA0BvD;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0B1E;AAED;;;;;;;;;;GAUG;AACH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAyBzD;AA0BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA2B3D;AASD,0DAA0D;AAC1D,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAgB3F;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA4JzF;AAED;;;;;;;;;GASG;AACH,sDAAsD;AACtD,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,iBAAkB,MAAM,KAAG,OAAgD,CAAC;AAEtG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB;IAC9B,SAAS,iBAAiB,MAAM,KAAG,OAAO;IAC1C,EAAE,UAAU,MAAM,KAAG,MAAM;CAa5B,CAAC;AASF,eAAO,MAAM,kBAAkB,iBAAkB,MAAM,KAAG,OACe,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,iBAAkB,MAAM,KAAG,OACiB,CAAC;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;IAClD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC5F,GACA,OAAO,CAAC,MAAM,CAAC,CAyDjB;AAED,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAe3F;AAED,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,2BAA2B,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxB,4EAA4E;IAC5E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;CAC1C,GAAG,MAAM,GAAG,IAAI,CA+BhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACnD,GAAG,OAAO,CAAC,SAAS,CAAC,CA8BrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,wBAAwB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,GACA,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoCxB;AASD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAMxD;AAOD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAuBD,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAIrE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,qBAAqB,CAAC,EAAE,MAAM,GAC7B,SAAS,UAAU,EAAE,CAmFvB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,SAAmB,GAAG,SAAS,UAAU,EAAE,CAoCtG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,GAAE,SAAS,MAAM,EAAO,GAAG,SAAS,UAAU,EAAE,CAgB7H"}