@crowdedkingdoms/crowdyjs 17.14.0-dev.1 → 18.0.0-dev.1

package/dist/kit/blueprints/core.js

@@ -1,185 +0,0 @@
-/** Serialize a {@link KitInvokePolicy} tree to the wire `invokePolicyJson`. */
-export function kitPolicyJson(policy) {
-    return JSON.stringify(policy);
-}
-/** Convert `PascalCase`/`camelCase` to `snake_case` for derived names. */
-export function toSnakeCase(name) {
-    return name
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        .replace(/[\s-]+/g, '_')
-        .toLowerCase();
-}
-/**
- * Merge blueprints into a single `gameModelSeed` payload plus the automation
- * upserts, rejecting duplicate type, property, function, or automation names
- * across blueprints (a duplicate almost always means two blueprints need
- * distinct prefixes/type names).
- */
-export function mergeBlueprints(appId, blueprints, options = {}) {
-    const containerTypes = [];
-    const propertyDefinitions = [];
-    const functions = [];
-    const containers = [];
-    const edges = [];
-    const automations = [];
-    const automationTriggers = [];
-    const seenTypes = new Map();
-    const seenProps = new Map();
-    const seenFunctions = new Map();
-    const seenAutomations = new Map();
-    const seenTempIds = new Map();
-    const claim = (seen, key, blueprintName, kind) => {
-        const existing = seen.get(key);
-        if (existing !== undefined) {
-            throw new Error(`Blueprint '${blueprintName}' redefines ${kind} '${key}' already defined by blueprint '${existing}'`);
-        }
-        seen.set(key, blueprintName);
-    };
-    for (const blueprint of blueprints) {
-        for (const type of blueprint.containerTypes ?? []) {
-            claim(seenTypes, type.typeName, blueprint.name, 'container type');
-            containerTypes.push(type);
-        }
-        for (const prop of blueprint.propertyDefinitions ?? []) {
-            claim(seenProps, `${prop.containerTypeName}.${prop.key}`, blueprint.name, 'property');
-            propertyDefinitions.push(prop);
-        }
-        for (const fn of blueprint.functions ?? []) {
-            claim(seenFunctions, fn.name, blueprint.name, 'function');
-            functions.push(fn);
-        }
-        for (const container of blueprint.containers ?? []) {
-            claim(seenTempIds, container.tempId, blueprint.name, 'container tempId');
-            containers.push(container);
-        }
-        edges.push(...(blueprint.edges ?? []));
-        for (const automation of blueprint.automations ?? []) {
-            claim(seenAutomations, automation.name, blueprint.name, 'automation');
-            automations.push({ ...automation, appId });
-        }
-        for (const trigger of blueprint.automationTriggers ?? []) {
-            automationTriggers.push({ ...trigger, appId });
-        }
-    }
-    const seedInput = {
-        appId,
-        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-        ...(containerTypes.length ? { containerTypes } : {}),
-        ...(propertyDefinitions.length ? { propertyDefinitions } : {}),
-        ...(functions.length ? { functions } : {}),
-        ...(containers.length ? { containers } : {}),
-        ...(edges.length ? { edges } : {}),
-    };
-    return { seedInput, automations, automationTriggers };
-}
-/**
- * Concatenate several blueprints into ONE composite blueprint (a plain
- * client-side merge of the definition arrays — no collision checks; those
- * happen in {@link mergeBlueprints} at deploy). Used by composite builders
- * such as `guildBlueprint` that bundle other builders' output under a single
- * name.
- */
-export function composeBlueprints(name, blueprints) {
-    const out = { name };
-    for (const bp of blueprints) {
-        if (bp.containerTypes?.length) {
-            out.containerTypes = [...(out.containerTypes ?? []), ...bp.containerTypes];
-        }
-        if (bp.propertyDefinitions?.length) {
-            out.propertyDefinitions = [
-                ...(out.propertyDefinitions ?? []),
-                ...bp.propertyDefinitions,
-            ];
-        }
-        if (bp.functions?.length) {
-            out.functions = [...(out.functions ?? []), ...bp.functions];
-        }
-        if (bp.containers?.length) {
-            out.containers = [...(out.containers ?? []), ...bp.containers];
-        }
-        if (bp.edges?.length) {
-            out.edges = [...(out.edges ?? []), ...bp.edges];
-        }
-        if (bp.automations?.length) {
-            out.automations = [...(out.automations ?? []), ...bp.automations];
-        }
-        if (bp.automationTriggers?.length) {
-            out.automationTriggers = [
-                ...(out.automationTriggers ?? []),
-                ...bp.automationTriggers,
-            ];
-        }
-    }
-    return out;
-}
-/**
- * The function-level fields a {@link KitTrustedAuthority} compiles to.
- * `extraCondition` (when given) is AND'ed into the policy.
- */
-export function trustedAuthorityFields(authority, extraCondition) {
-    const rule = authority === 'server'
-        ? { type: 'allow' }
-        : authority === 'host'
-            ? { type: 'is_host' }
-            : authority === 'automation'
-                ? { type: 'is_automation' }
-                : authority === 'owner'
-                    ? { type: 'owner_of_self' }
-                    : authority.custom;
-    const policy = extraCondition
-        ? { type: 'and', rules: [rule, { type: 'condition', expression: extraCondition }] }
-        : rule;
-    return {
-        invokePolicyJson: kitPolicyJson(policy),
-        ...(authority === 'server' ? { invokeScope: 'server' } : {}),
-        ...(authority === 'automation' ? { autonomousInvocable: true } : {}),
-    };
-}
-/**
- * AND extra policy rules into a base policy (skipping empties) — the
- * composition point for `policyExtra` options such as
- * `plotBlueprint({ buyPolicyExtra: featureGate('land_owner') })`.
- */
-export function andPolicies(base, ...extra) {
-    const extras = extra.filter((r) => r !== undefined);
-    if (extras.length === 0)
-        return base;
-    return { type: 'and', rules: [base, ...extras] };
-}
-/**
- * A `tier_feature` policy leaf: the caller's access tier must hold `feature`
- * (defined via `kit.features.define` and granted with
- * `kit.features.grantToTier`). Pass it to any builder's `*policyExtra`
- * option to monetization-gate that function.
- */
-export function featureGate(feature) {
-    return { type: 'tier_feature', feature };
-}
-/**
- * Expression fragment asserting that `ownerExpr` (an `owner_user_id`-style
- * property read) equals a user-id expression (usually the injected
- * `$caller_user_id` / `$self_owner_id` system params), honoring
- * {@link KitOwnerIdKind}.
- */
-export function ownerEquals(ownerExpr, userExpr, kind = 'int') {
-    return kind === 'string'
-        ? `${ownerExpr} == to_string(${userExpr})`
-        : `${ownerExpr} == ${userExpr}`;
-}
-/**
- * Expression fragment asserting that `ownerExpr` (an `owner_user_id`-style
- * property read) equals the calling user, honoring {@link KitOwnerIdKind}.
- */
-export function ownerEqualsCaller(ownerExpr, kind = 'int') {
-    return ownerEquals(ownerExpr, '$caller_user_id', kind);
-}
-/** The `SeedPropertyDefInput` for a kit-standard owner mirror property. */
-export function ownerMirrorProperty(containerTypeName, kind = 'int') {
-    return {
-        containerTypeName,
-        key: 'owner_user_id',
-        valueType: kind,
-        defaultValueJson: kind === 'string' ? '""' : '0',
-        description: "Mirror of the container owner's user id (kit convention: expressions cannot read container ownership).",
-    };
-}

package/dist/kit/blueprints/decks.d.ts

@@ -1,50 +0,0 @@
-import { type KitBlueprint, type KitOwnerIdKind } from './core.js';
-/** Options for {@link decksBlueprint}. */
-export interface DecksBlueprintOptions {
-    /** Prefix for the type/function names. Defaults to none. */
-    typePrefix?: string;
-    /**
-     * Turn-based mode: adds `is_current_turn` to draw/play/discard, so only
-     * the player whose session turn it is may act. Defaults to false.
-     */
-    turnBased?: boolean;
-    /**
-     * Fan-out cap of the manual shuffle automation (raise it above your
-     * largest deck size). Defaults to 200.
-     */
-    shuffleMaxTargets?: number;
-    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
-    ownerIdKind?: KitOwnerIdKind;
-}
-/** Names derived by {@link decksBlueprint} for a given prefix. */
-export interface DecksNames {
-    cardDefType: string;
-    cardType: string;
-    drawFn: string;
-    playFn: string;
-    discardFn: string;
-    assignPositionFn: string;
-    shuffleAutomation: string;
-}
-/** Compute the type/function names a decks blueprint (and its runtime helper) uses. */
-export declare function decksNames(typePrefix?: string): DecksNames;
-/**
- * Blueprint for **cards & hidden information**: an admin `CardDef` catalog
- * and session-scoped `CardInstance`s whose `card_id` carries
- * **`visibility: "owner"`** — the two-property hidden-info trick: only the
- * owner's reads include `card_id`, while the public `revealed_card_id` stays
- * empty until the card is played/discarded (the play function copies it in
- * the same transaction). Opponents can see a card EXISTS in your hand, not
- * what it is — enforced by read filtering, not client discipline.
- *
- * Shuffling is honest about the platform: expressions can't index arrays, so
- * decks are ordered by a `position` int dealt by `assign_position`
- * (`rand_int(0, 1000000)` per card) via a **manual, type-fan-out
- * automation** — `kit.decks.shuffle()` runs it (admin), and drawing takes
- * the owner's lowest-position deck card ("top of deck"; the runtime picks
- * it, the server enforces the zone transition and ownership).
- *
- * Runtime counterpart: `client.kit(appId).decks`.
- */
-export declare function decksBlueprint(options?: DecksBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=decks.d.ts.map

package/dist/kit/blueprints/decks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decks.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/decks.ts"],"names":[],"mappings":"AAIA,OAAO,EAKL,KAAK,YAAY,EAEjB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAEnB,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,kEAAkE;AAClE,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,UAAU,SAAK,GAAG,UAAU,CAWtD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,YAAY,CAoJhF"}

package/dist/kit/blueprints/decks.js

@@ -1,163 +0,0 @@
-import { kitPolicyJson, ownerMirrorProperty, toSnakeCase, } from './core.js';
-/** Compute the type/function names a decks blueprint (and its runtime helper) uses. */
-export function decksNames(typePrefix = '') {
-    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return {
-        cardDefType: `${typePrefix}CardDef`,
-        cardType: `${typePrefix}CardInstance`,
-        drawFn: `${fnPrefix}draw_card`,
-        playFn: `${fnPrefix}play_card`,
-        discardFn: `${fnPrefix}discard_card`,
-        assignPositionFn: `${fnPrefix}assign_position`,
-        shuffleAutomation: `${fnPrefix.replace(/_/g, '-')}deck-shuffle`,
-    };
-}
-/**
- * Blueprint for **cards & hidden information**: an admin `CardDef` catalog
- * and session-scoped `CardInstance`s whose `card_id` carries
- * **`visibility: "owner"`** — the two-property hidden-info trick: only the
- * owner's reads include `card_id`, while the public `revealed_card_id` stays
- * empty until the card is played/discarded (the play function copies it in
- * the same transaction). Opponents can see a card EXISTS in your hand, not
- * what it is — enforced by read filtering, not client discipline.
- *
- * Shuffling is honest about the platform: expressions can't index arrays, so
- * decks are ordered by a `position` int dealt by `assign_position`
- * (`rand_int(0, 1000000)` per card) via a **manual, type-fan-out
- * automation** — `kit.decks.shuffle()` runs it (admin), and drawing takes
- * the owner's lowest-position deck card ("top of deck"; the runtime picks
- * it, the server enforces the zone transition and ownership).
- *
- * Runtime counterpart: `client.kit(appId).decks`.
- */
-export function decksBlueprint(options = {}) {
-    const { typePrefix = '', turnBased = false, shuffleMaxTargets = 200, ownerIdKind: kind = 'int', } = options;
-    const names = decksNames(typePrefix);
-    const playerPolicy = (condition) => {
-        const rules = [
-            { type: 'owner_of_self' },
-            ...(turnBased ? [{ type: 'is_current_turn' }] : []),
-            { type: 'condition', expression: condition },
-        ];
-        return kitPolicyJson({ type: 'and', rules });
-    };
-    const propertyDefinitions = [
-        {
-            containerTypeName: names.cardDefType,
-            key: 'card_id',
-            valueType: 'string',
-            description: 'Stable card identifier (rules data lives on the def).',
-        },
-        ownerMirrorProperty(names.cardType, kind),
-        {
-            containerTypeName: names.cardType,
-            key: 'card_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            visibility: 'owner',
-            description: "WHICH card this is — owner-visible only (the hidden-information half of the two-property trick); opponents' reads omit it.",
-        },
-        {
-            containerTypeName: names.cardType,
-            key: 'revealed_card_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'The public half: empty while the card hides in deck/hand, copied from card_id when played or discarded.',
-        },
-        {
-            containerTypeName: names.cardType,
-            key: 'zone',
-            valueType: 'string',
-            defaultValueJson: '"deck"',
-            description: "Card zone: 'deck' | 'hand' | 'board' | 'discard'.",
-        },
-        {
-            containerTypeName: names.cardType,
-            key: 'position',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Deck order (lowest = top), dealt by the shuffle automation via rand_int.',
-        },
-    ];
-    const functions = [
-        {
-            name: names.drawFn,
-            containerTypeName: names.cardType,
-            returnType: 'string',
-            mutations: [{ target: 'self', property: 'zone', expression: '"hand"' }],
-            returnExpression: 'self.zone',
-            invokePolicyJson: playerPolicy('self.zone == "deck"'),
-            description: 'Draw a card you own from your deck into your hand (the runtime picks the lowest-position deck card — "top of deck"); card_id stays owner-visible.',
-        },
-        {
-            name: names.playFn,
-            containerTypeName: names.cardType,
-            returnType: 'string',
-            mutations: [
-                { target: 'self', property: 'zone', expression: '"board"' },
-                { target: 'self', property: 'revealed_card_id', expression: 'self.card_id' },
-            ],
-            returnExpression: 'self.revealed_card_id',
-            invokePolicyJson: playerPolicy('self.zone == "hand"'),
-            description: 'Play a card from your hand: the zone flip AND the public reveal (revealed_card_id = card_id) commit together.',
-        },
-        {
-            name: names.discardFn,
-            containerTypeName: names.cardType,
-            returnType: 'string',
-            mutations: [
-                { target: 'self', property: 'zone', expression: '"discard"' },
-                { target: 'self', property: 'revealed_card_id', expression: 'self.card_id' },
-            ],
-            returnExpression: 'self.revealed_card_id',
-            invokePolicyJson: playerPolicy('self.zone == "hand" || self.zone == "board"'),
-            description: 'Discard a card face-up (discard piles are public information).',
-        },
-        {
-            name: names.assignPositionFn,
-            containerTypeName: names.cardType,
-            returnType: 'int',
-            mutations: [
-                { target: 'self', property: 'position', expression: 'rand_int(0, 1000000)' },
-            ],
-            returnExpression: 'self.position',
-            invokePolicyJson: kitPolicyJson({ type: 'is_automation' }),
-            autonomousInvocable: true,
-            description: 'Shuffle step (automation-only): deals this card a random deck position — the supported server-side shuffle pattern (expressions cannot permute arrays).',
-        },
-    ];
-    const automations = [
-        {
-            name: names.shuffleAutomation,
-            functionName: names.assignPositionFn,
-            targetMode: 'type',
-            targetTypeName: names.cardType,
-            triggerType: 'manual',
-            maxTargets: shuffleMaxTargets,
-            selectorJson: JSON.stringify({
-                selfWhere: [{ key: 'zone', op: '==', value: 'deck' }],
-            }),
-            description: 'Manual shuffle: fans assign_position out over every deck-zone card (run via gameModelRunAutomation / kit.decks.shuffle).',
-        },
-    ];
-    return {
-        name: names.cardType,
-        containerTypes: [
-            {
-                typeName: names.cardDefType,
-                displayName: names.cardDefType,
-                instantiableBy: 'admin',
-                description: 'Studio card catalog row.',
-            },
-            {
-                typeName: names.cardType,
-                displayName: names.cardType,
-                instantiableBy: 'member',
-                description: 'One card in play: hidden while in deck/hand (owner-visible card_id), public once revealed.',
-            },
-        ],
-        propertyDefinitions,
-        functions,
-        automations,
-    };
-}

package/dist/kit/blueprints/economy.d.ts

@@ -1,88 +0,0 @@
-import { type KitBlueprint, type KitOwnerIdKind, type KitTrustedAuthority } from './core.js';
-/** Options for {@link economyBlueprint}. */
-export interface EconomyBlueprintOptions {
-    /**
-     * Prefix applied to the container type names (`'Black'` → `BlackWallet` /
-     * `BlackShopListing` / …) and, snake-cased, to the function names
-     * (`black_earn_gold`, …). Lets several economies coexist. Defaults to none.
-     */
-    typePrefix?: string;
-    /**
-     * Currency property names on the wallet, one int property (default 0) per
-     * entry, each with `earn_<c>` / `spend_<c>` functions. Defaults to
-     * `['gold']`.
-     */
-    currencies?: string[];
-    /**
-     * The wallet currency shops and market listings are priced in. Defaults to
-     * the first entry of `currencies`. (Expressions cannot pick a wallet
-     * property dynamically, so one deployment trades in one currency; deploy a
-     * prefixed second blueprint for a second shop currency.)
-     */
-    shopCurrency?: string;
-    /**
-     * Who may mint currency via `earn_<c>`. Trusted grants should be `'server'`
-     * (app admins / studio backend, the default), `'host'`, or
-     * `'automation'` — never plain players. Defaults to `'server'`.
-     */
-    earnAuthority?: KitTrustedAuthority;
-    /**
-     * How `owner_user_id` mirrors are typed on the stack containers this
-     * economy guards (see the kit owner-mirroring convention). Defaults to
-     * `'int'` (the kit standard).
-     */
-    ownerIdKind?: KitOwnerIdKind;
-    /**
-     * When set, adds a `restock_listing` automation that periodically raises
-     * every listing's `stock` (by `amount`, clamped to `max_stock`) — the NPC
-     * trader restock pattern.
-     */
-    restock?: {
-        intervalMs: number;
-        amount?: number;
-    };
-}
-/** Names derived by {@link economyBlueprint} for a given prefix. */
-export interface EconomyNames {
-    walletType: string;
-    listingType: string;
-    tradeType: string;
-    marketType: string;
-    /** Snake-cased function-name prefix (empty without a `typePrefix`). */
-    fnPrefix: string;
-    buyListingFn: string;
-    acceptTradeFn: string;
-    cancelTradeFn: string;
-    buyMarketFn: string;
-    cancelMarketFn: string;
-    restockFn: string;
-    restockAutomation: string;
-}
-/** Compute the type/function names an economy blueprint (and its runtime helper) uses. */
-export declare function economyNames(typePrefix?: string): EconomyNames;
-/** The earn/spend function name for one currency. */
-export declare function economyCurrencyFn(verb: 'earn' | 'spend', currency: string, typePrefix?: string): string;
-/**
- * Blueprint for a server-authoritative **economy**: per-player `Wallet`
- * containers (one int property per currency), an admin `ShopListing` catalog
- * with an atomic `buy_listing` (wallet debit + stock decrement + item grant
- * in ONE invoke), escrow `TradeOffer` swaps, and a player-to-player
- * `MarketListing` flow (buyer wallet → seller wallet + stack transfer, all
- * in one transaction).
- *
- * Anti-duplication is structural: every movement of currency or items is a
- * single function invocation whose condition guards check balances, stock,
- * item identity, and ownership mirrors server-side — never split a spend and
- * a grant across two invokes. Trusted mints (`earn_<c>`) default to
- * `invokeScope: "server"` (app admins only).
- *
- * Trade/market guards verify stack ownership through the kit-standard
- * `owner_user_id` mirror property on the stack type (the inventory blueprint
- * defines it; set it via `InventoryKit.createStack({ ownerUserId })`), and
- * pin the offer creator via the injected `$self_owner_id` — the server-truth
- * owner of the offer/listing container.
- *
- * Runtime counterpart: `client.kit(appId).economy`.
- */
-export declare function economyBlueprint(options?: EconomyBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=economy.d.ts.map

package/dist/kit/blueprints/economy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"economy.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/economy.ts"],"names":[],"mappings":"AAIA,OAAO,EAQL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC;;;;OAIG;IACH,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnD;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,UAAU,SAAK,GAAG,YAAY,CAgB1D;AAED,qDAAqD;AACrD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,QAAQ,EAAE,MAAM,EAChB,UAAU,SAAK,GACd,MAAM,CAGR;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,uBAA4B,GACpC,YAAY,CAyfd"}