@vgai/engine 0.5.0 → 0.5.2

package/dist/manifest/load.js

@@ -1,273 +0,0 @@
-// T3.1 slice 1 — the game manifest loader/validator (docs/GAME-MANIFEST-DESIGN.md §5).
-//
-// Pure data-in/data-out: `loadGameManifest(raw)` parses `raw` against
-// `GameManifestSchema`, runs the cross-field checks §3 promises beyond what
-// Zod alone can express, resolves every optional/derivable field, and
-// returns a `ResolvedGameManifest` with nothing left implicit. This is the
-// schema's runtime reader (T4.1 policy) — every described field in
-// `schema.ts` either drives a check here or is carried into the resolved
-// output explicitly (see the per-field comments below and
-// `packages/engine/test/schema-consumption-map.ts`'s `manifest.*` entries).
-//
-// No `fs` import here on purpose — `load-file.ts` is the thin Node-only
-// wrapper that reads a path and calls this function, so browser bundles that
-// only need `loadGameManifest` never pull in `node:fs`.
-import { GameManifestSchema, } from './schema';
-// ---------------------------------------------------------------------------
-// §4 — the per-context ceiling table (named + exported: the tier-table doc
-// test in slice 2 pins docs/CAPABILITY-TIERS.md's rows against this).
-// ---------------------------------------------------------------------------
-/**
- * Ceiling (maximum legal declared `Tier`) per adapter type and delivery
- * context. `default` roots are always first-party in both contexts (D6/§2 —
- * a first-party root is fully vgai-native everywhere). `ingest` roots are
- * ceilinged by their own capture `strategy`: locally the local CLI's Vite
- * pipeline gives bundler dedupe, so every strategy reaches its own natural
- * rung; hosted has no bundler (esbuild-wasm + externals only), and a
- * `deduped` root is DEFINED by being source built through our pipeline — no
- * prebuilt bundle exists to fall back to an iframe rung, and nothing
- * implements a hosted build for it, so hosted is `unsupported` (honesty over
- * optimism; if the hosted esbuild-wasm path ever proves capable, raising
- * this ceiling is a non-breaking widening). `shared`/`iframe-reachable`/
- * `opaque-embed` don't depend on a bundler either way, so they carry through
- * unchanged. `module` adapters have no derivable ceiling ("a custom
- * adapter's reach is not derivable", §4) — modeled here as `first-party`
- * (the top rank), i.e. no ceiling actually constrains a module adapter's
- * declared tier; the loader instead requires the tier to be declared
- * explicitly for module roots (see `resolveCapabilities`), since there is no
- * default to derive.
- */
-export const CAPABILITY_CEILINGS = {
-    builtin: { local: 'first-party', hosted: 'first-party' },
-    ingest: {
-        shared: { local: 'shared', hosted: 'shared' },
-        deduped: { local: 'deduped', hosted: 'unsupported' },
-        'iframe-reachable': { local: 'iframe-reachable', hosted: 'iframe-reachable' },
-        'opaque-embed': { local: 'opaque-embed', hosted: 'opaque-embed' },
-    },
-    module: { local: 'first-party', hosted: 'first-party' },
-};
-/** Total order over `Tier` (§4: `first-party > shared ≈ deduped > iframe-reachable > opaque-embed > unsupported`). */
-const TIER_RANK = {
-    'first-party': 5,
-    shared: 4,
-    deduped: 4,
-    'iframe-reachable': 3,
-    'opaque-embed': 2,
-    unsupported: 1,
-};
-/** Default relative path for `server.module` when omitted (§3) — the scaffolded Colyseus bootstrap. */
-export const DEFAULT_SERVER_MODULE = 'server/colyseus-setup.ts';
-const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/;
-// ---------------------------------------------------------------------------
-// Adapter shape guards
-// ---------------------------------------------------------------------------
-function isModuleAdapter(adapter) {
-    return typeof adapter === 'object' && 'module' in adapter;
-}
-function isIngestAdapter(adapter) {
-    return typeof adapter === 'object' && 'ingest' in adapter;
-}
-// ---------------------------------------------------------------------------
-// Cross-field checks (§3 — beyond what Zod alone enforces)
-// ---------------------------------------------------------------------------
-//
-// D-V6 (docs/WAVE5-MULTIWORLD-INGEST-DESIGN.md): root-id uniqueness used to
-// be a cross-field check HERE (`checkUniqueWorldIds`, removed) — it moved
-// INTO `GameManifestSchema`'s `roots` `superRefine` (schema.ts) instead, so
-// the generated JSON Schema and any other schema consumer see the same
-// constraint the loader always enforced. `parseManifest` below catches that
-// one recognizable schema-level issue and rethrows it as a clean, single
-// `Error` — the exact message shape `checkUniqueWorldIds` used to throw
-// directly — rather than a raw multi-issue `ZodError` dump, so existing
-// callers/tests that pattern-match the message text are unaffected by the
-// enforcement moving one layer down.
-function checkAdapterSceneEntryRules(root) {
-    const { adapter } = root;
-    if (typeof adapter === 'string' && !root.scene && !root.entry) {
-        throw new Error(`Game manifest: root "${root.id}" uses the '${adapter}' adapter but declares neither ` +
-            '`scene` nor `entry` — a built-in adapter root requires an authored document or entry.');
-    }
-    if (adapter === 'react' && root.scene !== undefined) {
-        throw new Error(`Game manifest: React root "${root.id}" declares \`scene\` — React roots use JSX entry modules.`);
-    }
-    if (isIngestAdapter(adapter) && root.scene !== undefined) {
-        throw new Error(`Game manifest: root "${root.id}" uses an { ingest } adapter but declares \`scene\` — ` +
-            'ingest adapters forbid `scene` (adapt-never-migrate: ingested games keep their own ' +
-            "formats; overlay persistence is T3.2's) (§3).");
-    }
-}
-// Historical note (Track N, N1): this file used to reject EVERY `kind:
-// 'react'` + `{ ingest }` root outright here (`checkReactAdapterRestriction`,
-// citing "no react ingest program is un-parked"). Track N un-parks exactly
-// that program (docs/REACT-INGEST-LANDING-DESIGN.md) — react+ingest is now a
-// structurally legal combination, resolved to the `'ingest-react'` identity
-// by `resolveAdapter` below like any other ingest root. There is nothing
-// left to reject at THIS layer: `checkAdapterSceneEntryRules` above already
-// forbids `scene` on any `{ ingest }`-adapter root (kind-agnostic), and the
-// v1 "deduped strategy only" restriction is an editor-resolver concern
-// (D-N3), not a manifest-shape concern — see the `ResolvedAdapter` type's
-// comment above.
-// ---------------------------------------------------------------------------
-// Resolution (§5)
-// ---------------------------------------------------------------------------
-function resolveAdapter(root) {
-    const { adapter } = root;
-    if (typeof adapter === 'string') {
-        return { type: 'builtin', identity: adapter, surface: adapter };
-    }
-    if (isModuleAdapter(adapter)) {
-        return {
-            type: 'module',
-            identity: 'module',
-            module: adapter.module,
-            surface: adapter.surface,
-        };
-    }
-    // isIngestAdapter (Track N, N1: 'ingest-react' joins 'ingest-three'/
-    // 'ingest-pixi' — see the `ResolvedAdapter` type's comment above for why
-    // this stays strategy-agnostic here).
-    const identity = adapter.surface === 'threejs'
-        ? 'ingest-three'
-        : adapter.surface === 'pixijs'
-            ? 'ingest-pixi'
-            : 'ingest-react';
-    const ingest = adapter.ingest;
-    return {
-        type: 'ingest',
-        identity,
-        surface: adapter.surface,
-        strategy: ingest.strategy,
-        entryHtml: ingest.entryHtml,
-        assets: ingest.assets,
-        domStubs: ingest.domStubs,
-        captureTimeoutMs: ingest.captureTimeoutMs,
-        bundleUrl: ingest.bundleUrl,
-        baseHref: ingest.baseHref,
-        assetBaseUrl: ingest.assetBaseUrl,
-        extraDeps: ingest.extraDeps,
-        pixiModuleUrl: ingest.pixiModuleUrl,
-        bodyHtml: ingest.bodyHtml,
-    };
-}
-function ceilingFor(adapter, context) {
-    if (typeof adapter === 'string')
-        return CAPABILITY_CEILINGS.builtin[context];
-    if (isModuleAdapter(adapter))
-        return CAPABILITY_CEILINGS.module[context];
-    return CAPABILITY_CEILINGS.ingest[adapter.ingest.strategy][context];
-}
-function resolveCapabilities(root) {
-    const contexts = ['local', 'hosted'];
-    const result = {};
-    for (const context of contexts) {
-        const declared = root.capabilities?.[context];
-        if (declared !== undefined) {
-            const ceiling = ceilingFor(root.adapter, context);
-            if (TIER_RANK[declared] > TIER_RANK[ceiling]) {
-                throw new Error(`Game manifest: root "${root.id}": declared capabilities.${context} tier "${declared}" ` +
-                    `exceeds the "${ceiling}" ceiling for this adapter in the ${context} context (§4). ` +
-                    'Under-claiming (including `unsupported`) is legal; over-claiming is not.');
-            }
-            result[context] = declared;
-            continue;
-        }
-        // Omitted -> derive.
-        if (typeof root.adapter === 'string') {
-            result[context] = 'first-party';
-        }
-        else if (isModuleAdapter(root.adapter)) {
-            throw new Error(`Game manifest: root "${root.id}": { module } adapter requires an explicit ` +
-                `capabilities.${context} declaration — a custom adapter's reach is not derivable (§4).`);
-        }
-        else {
-            result[context] = CAPABILITY_CEILINGS.ingest[root.adapter.ingest.strategy][context];
-        }
-    }
-    return result;
-}
-function checkEngineVersionPin(version) {
-    if (!SEMVER_RE.test(version)) {
-        throw new Error(`Game manifest: engine.version "${version}" is not a valid exact semver string (e.g. ` +
-            '"0.1.0") — §1.5 requires an exact identity pin, not a range.');
-    }
-}
-/**
- * Resolve one already-Zod-validated root entry into its `ResolvedAdapterRoot`
- * (adapter identity, capabilities, and a pass-through of every other field).
- * Every `AdapterRoot` field participates here or in a check above:
- * `id` drives uniqueness; `adapter` (incl. its surface and
- * `module`/`ingest.*` sub-fields) drives identity + capability-ceiling
- * resolution; `scene`/`entry` drive the scene/entry cross-field rule and are
- * carried through; `zOrder` drives the final sort; `pausable`/`loop` are
- * carried through as-is (their consumers are the runtime/CLI, T3.2/T3.3);
- * `capabilities.{local,hosted}` drive tier resolution; `description` (T3.3
- * slice 3) is carried through as-is — its consumer today is
- * `resolveIngestDescriptor` (packages/editor/src/adapter-resolver.ts), which
- * threads an ingest-three root's description into `IngestGame.description`.
- */
-function resolveRoot(root) {
-    checkAdapterSceneEntryRules(root);
-    const adapter = resolveAdapter(root);
-    return {
-        id: root.id,
-        surface: adapter.surface,
-        description: root.description,
-        adapter,
-        scene: root.scene,
-        entry: root.entry,
-        zOrder: root.zOrder,
-        pausable: root.pausable,
-        loop: root.loop,
-        capabilities: resolveCapabilities(root),
-    };
-}
-// ---------------------------------------------------------------------------
-// Entry point
-// ---------------------------------------------------------------------------
-/**
- * Parse + validate + resolve a raw manifest value into a `ResolvedGameManifest`.
- * Pure data-in/data-out (no `fs`) — see `load-file.ts` for the Node path-based
- * wrapper. Throws a descriptive `Error` (naming the offending root/field) on
- * any Zod validation failure or cross-field rule violation.
- */
-export function loadGameManifest(raw) {
-    const parsed = GameManifestSchema.safeParse(raw);
-    if (!parsed.success) {
-        // D-V6: the `roots` `superRefine`'s duplicate-id issue is the one
-        // schema-level violation this loader still surfaces as a clean, single
-        // `Error` (matching `checkUniqueWorldIds`'s pre-D-V6 message shape) —
-        // every other schema violation keeps propagating as the raw `ZodError`
-        // it always has (unchanged behavior, e.g. the iframe-reachable
-        // field-exclusivity / manifestVersion checks).
-        const dupIssue = parsed.error.issues.find((issue) => issue.message.startsWith('Game manifest: duplicate root id'));
-        if (dupIssue)
-            throw new Error(dupIssue.message);
-        throw parsed.error;
-    }
-    const manifest = parsed.data;
-    checkEngineVersionPin(manifest.engine.version);
-    const resolvedWithIndex = manifest.roots.map((root, index) => ({
-        root: resolveRoot(root),
-        index,
-    }));
-    resolvedWithIndex.sort((a, b) => a.root.zOrder - b.root.zOrder || a.index - b.index);
-    const roots = resolvedWithIndex.map(({ root }) => root);
-    const server = manifest.server
-        ? { room: manifest.server.room, module: manifest.server.module ?? DEFAULT_SERVER_MODULE }
-        : undefined;
-    return {
-        manifestVersion: manifest.manifestVersion,
-        name: manifest.name,
-        appId: manifest.appId,
-        editorPort: manifest.editorPort,
-        version: manifest.version,
-        engine: { version: manifest.engine.version },
-        roots,
-        server,
-        resolution: manifest.resolution,
-        authoring: manifest.authoring,
-        debug: manifest.debug,
-        determinism: manifest.determinism,
-    };
-}

package/dist/manifest/schema.d.ts

@@ -1,230 +0,0 @@
-import { z } from 'zod';
-/**
- * Current on-disk `vgai.game.json` format. Exported so editor/server
- * compatibility checks do not duplicate the schema's literal value.
- */
-export declare const GAME_MANIFEST_VERSION: 2;
-export declare const IngestStrategySchema: z.ZodEnum<{
-    shared: "shared";
-    deduped: "deduped";
-    "iframe-reachable": "iframe-reachable";
-    "opaque-embed": "opaque-embed";
-}>;
-export type IngestStrategy = z.infer<typeof IngestStrategySchema>;
-export declare const TierSchema: z.ZodEnum<{
-    shared: "shared";
-    deduped: "deduped";
-    "iframe-reachable": "iframe-reachable";
-    "opaque-embed": "opaque-embed";
-    "first-party": "first-party";
-    unsupported: "unsupported";
-}>;
-export type Tier = z.infer<typeof TierSchema>;
-export declare const RootAdapterSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    threejs: "threejs";
-    pixijs: "pixijs";
-    react: "react";
-}>, z.ZodObject<{
-    module: z.ZodString;
-    surface: z.ZodEnum<{
-        threejs: "threejs";
-        pixijs: "pixijs";
-        react: "react";
-    }>;
-}, z.core.$strict>, z.ZodObject<{
-    surface: z.ZodEnum<{
-        threejs: "threejs";
-        pixijs: "pixijs";
-        react: "react";
-    }>;
-    ingest: z.ZodObject<{
-        strategy: z.ZodEnum<{
-            shared: "shared";
-            deduped: "deduped";
-            "iframe-reachable": "iframe-reachable";
-            "opaque-embed": "opaque-embed";
-        }>;
-        entryHtml: z.ZodOptional<z.ZodString>;
-        assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        domStubs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        captureTimeoutMs: z.ZodOptional<z.ZodNumber>;
-        bundleUrl: z.ZodOptional<z.ZodString>;
-        baseHref: z.ZodOptional<z.ZodString>;
-        assetBaseUrl: z.ZodOptional<z.ZodString>;
-        extraDeps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        pixiModuleUrl: z.ZodOptional<z.ZodString>;
-        bodyHtml: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strict>]>;
-export type RootAdapter = z.infer<typeof RootAdapterSchema>;
-export declare const AdapterRootSchema: z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    adapter: z.ZodUnion<readonly [z.ZodEnum<{
-        threejs: "threejs";
-        pixijs: "pixijs";
-        react: "react";
-    }>, z.ZodObject<{
-        module: z.ZodString;
-        surface: z.ZodEnum<{
-            threejs: "threejs";
-            pixijs: "pixijs";
-            react: "react";
-        }>;
-    }, z.core.$strict>, z.ZodObject<{
-        surface: z.ZodEnum<{
-            threejs: "threejs";
-            pixijs: "pixijs";
-            react: "react";
-        }>;
-        ingest: z.ZodObject<{
-            strategy: z.ZodEnum<{
-                shared: "shared";
-                deduped: "deduped";
-                "iframe-reachable": "iframe-reachable";
-                "opaque-embed": "opaque-embed";
-            }>;
-            entryHtml: z.ZodOptional<z.ZodString>;
-            assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            domStubs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            captureTimeoutMs: z.ZodOptional<z.ZodNumber>;
-            bundleUrl: z.ZodOptional<z.ZodString>;
-            baseHref: z.ZodOptional<z.ZodString>;
-            assetBaseUrl: z.ZodOptional<z.ZodString>;
-            extraDeps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            pixiModuleUrl: z.ZodOptional<z.ZodString>;
-            bodyHtml: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>;
-    scene: z.ZodOptional<z.ZodString>;
-    entry: z.ZodOptional<z.ZodString>;
-    zOrder: z.ZodDefault<z.ZodNumber>;
-    pausable: z.ZodDefault<z.ZodBoolean>;
-    loop: z.ZodDefault<z.ZodEnum<{
-        gated: "gated";
-        "self-driven": "self-driven";
-    }>>;
-    capabilities: z.ZodOptional<z.ZodObject<{
-        local: z.ZodOptional<z.ZodEnum<{
-            shared: "shared";
-            deduped: "deduped";
-            "iframe-reachable": "iframe-reachable";
-            "opaque-embed": "opaque-embed";
-            "first-party": "first-party";
-            unsupported: "unsupported";
-        }>>;
-        hosted: z.ZodOptional<z.ZodEnum<{
-            shared: "shared";
-            deduped: "deduped";
-            "iframe-reachable": "iframe-reachable";
-            "opaque-embed": "opaque-embed";
-            "first-party": "first-party";
-            unsupported: "unsupported";
-        }>>;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-export type AdapterRoot = z.infer<typeof AdapterRootSchema>;
-export declare const GameManifestSchema: z.ZodObject<{
-    $schema: z.ZodOptional<z.ZodString>;
-    manifestVersion: z.ZodLiteral<2>;
-    name: z.ZodString;
-    appId: z.ZodOptional<z.ZodString>;
-    editorPort: z.ZodOptional<z.ZodNumber>;
-    version: z.ZodString;
-    engine: z.ZodObject<{
-        version: z.ZodString;
-    }, z.core.$strip>;
-    roots: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        adapter: z.ZodUnion<readonly [z.ZodEnum<{
-            threejs: "threejs";
-            pixijs: "pixijs";
-            react: "react";
-        }>, z.ZodObject<{
-            module: z.ZodString;
-            surface: z.ZodEnum<{
-                threejs: "threejs";
-                pixijs: "pixijs";
-                react: "react";
-            }>;
-        }, z.core.$strict>, z.ZodObject<{
-            surface: z.ZodEnum<{
-                threejs: "threejs";
-                pixijs: "pixijs";
-                react: "react";
-            }>;
-            ingest: z.ZodObject<{
-                strategy: z.ZodEnum<{
-                    shared: "shared";
-                    deduped: "deduped";
-                    "iframe-reachable": "iframe-reachable";
-                    "opaque-embed": "opaque-embed";
-                }>;
-                entryHtml: z.ZodOptional<z.ZodString>;
-                assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                domStubs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                captureTimeoutMs: z.ZodOptional<z.ZodNumber>;
-                bundleUrl: z.ZodOptional<z.ZodString>;
-                baseHref: z.ZodOptional<z.ZodString>;
-                assetBaseUrl: z.ZodOptional<z.ZodString>;
-                extraDeps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                pixiModuleUrl: z.ZodOptional<z.ZodString>;
-                bodyHtml: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-        }, z.core.$strict>]>;
-        scene: z.ZodOptional<z.ZodString>;
-        entry: z.ZodOptional<z.ZodString>;
-        zOrder: z.ZodDefault<z.ZodNumber>;
-        pausable: z.ZodDefault<z.ZodBoolean>;
-        loop: z.ZodDefault<z.ZodEnum<{
-            gated: "gated";
-            "self-driven": "self-driven";
-        }>>;
-        capabilities: z.ZodOptional<z.ZodObject<{
-            local: z.ZodOptional<z.ZodEnum<{
-                shared: "shared";
-                deduped: "deduped";
-                "iframe-reachable": "iframe-reachable";
-                "opaque-embed": "opaque-embed";
-                "first-party": "first-party";
-                unsupported: "unsupported";
-            }>>;
-            hosted: z.ZodOptional<z.ZodEnum<{
-                shared: "shared";
-                deduped: "deduped";
-                "iframe-reachable": "iframe-reachable";
-                "opaque-embed": "opaque-embed";
-                "first-party": "first-party";
-                unsupported: "unsupported";
-            }>>;
-        }, z.core.$strip>>;
-    }, z.core.$strict>>;
-    authoring: z.ZodOptional<z.ZodObject<{
-        hierarchy: z.ZodOptional<z.ZodObject<{
-            rootLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                label: z.ZodString;
-                roots: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    server: z.ZodOptional<z.ZodObject<{
-        room: z.ZodString;
-        module: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    resolution: z.ZodOptional<z.ZodObject<{
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-    }, z.core.$strip>>;
-    debug: z.ZodOptional<z.ZodObject<{
-        allowInProduction: z.ZodBoolean;
-    }, z.core.$strip>>;
-    determinism: z.ZodOptional<z.ZodObject<{
-        seededRandom: z.ZodBoolean;
-        defaultSeed: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-export type GameManifest = z.infer<typeof GameManifestSchema>;
-//# sourceMappingURL=schema.d.ts.map

package/dist/manifest/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/manifest/schema.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAMhD,eAAO,MAAM,oBAAoB;;;;;EAK/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE,eAAO,MAAM,UAAU;;;;;;;EAOrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAS9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAuL3B,CAAC;AACJ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAM5D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4DnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAM5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8JsD,CAAC;AAEtF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}