simfile 0.0.1

package/dist/schema/binding.js

@@ -0,0 +1,249 @@
+import { readFile } from "node:fs/promises";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const addIfDefined = (target, value) => {
+    if (typeof value === "string" && value.trim()) {
+        target.add(value);
+    }
+};
+const parseRoomScope = (value) => {
+    if (!value.startsWith("room:")) {
+        return undefined;
+    }
+    const rest = value.slice("room:".length);
+    const separatorIndex = rest.indexOf(":");
+    if (separatorIndex < 0 || separatorIndex === rest.length - 1) {
+        return undefined;
+    }
+    return `room:${rest.slice(0, separatorIndex)}:${rest.slice(separatorIndex + 1)}`;
+};
+const parseAgentScope = (value) => {
+    if (!value.startsWith("agent:")) {
+        return undefined;
+    }
+    const agentId = value.slice("agent:".length);
+    return agentId ? `agent:${agentId}` : undefined;
+};
+const parseTeamScope = (value) => {
+    if (!value.startsWith("team:")) {
+        return undefined;
+    }
+    const teamId = value.slice("team:".length);
+    return teamId ? `team:${teamId}` : undefined;
+};
+const createEmptyScopeIndex = () => ({
+    agents: new Set(),
+    rooms: new Set(),
+    teams: new Set()
+});
+const addTeamAndAgentScopes = (index, node) => {
+    if (typeof node.id !== "string") {
+        return;
+    }
+    const [kind, id] = node.id.split(":");
+    if (kind === "agent") {
+        addIfDefined(index.agents, id);
+    }
+    if (kind === "team") {
+        addIfDefined(index.teams, id);
+    }
+};
+const collectRoomScopes = (index, activeEnvironments) => {
+    if (!isRecord(activeEnvironments)) {
+        return;
+    }
+    const moltnet = activeEnvironments.moltnet;
+    if (!isRecord(moltnet)) {
+        return;
+    }
+    for (const [networkId, networkBinding] of Object.entries(moltnet)) {
+        if (!isRecord(networkBinding) || typeof networkId !== "string" || !networkId.trim()) {
+            continue;
+        }
+        const rooms = networkBinding.rooms;
+        if (!isRecord(rooms)) {
+            continue;
+        }
+        for (const roomId of Object.keys(rooms)) {
+            if (!roomId.trim()) {
+                continue;
+            }
+            index.rooms.add(`room:${networkId}:${roomId}`);
+        }
+    }
+};
+export const createReportScopeIndex = (report) => {
+    const index = createEmptyScopeIndex();
+    if (!isRecord(report) || !Array.isArray(report.nodes)) {
+        return index;
+    }
+    for (const nodeValue of report.nodes) {
+        if (!isRecord(nodeValue)) {
+            continue;
+        }
+        const node = nodeValue;
+        addTeamAndAgentScopes(index, node);
+        collectRoomScopes(index, node.active_environments);
+    }
+    return index;
+};
+const addMissingAgentDiagnostic = (agentScope, location, index, diagnostics) => {
+    if (!index.agents.has(agentScope.slice("agent:".length))) {
+        diagnostics.push({
+            level: "error",
+            message: `${location} references unknown agent ${agentScope}`
+        });
+    }
+};
+const addMissingTeamDiagnostic = (teamScope, location, index, diagnostics) => {
+    if (!index.teams.has(teamScope.slice("team:".length))) {
+        diagnostics.push({
+            level: "error",
+            message: `${location} references unknown team ${teamScope}`
+        });
+    }
+};
+const addMissingRoomDiagnostic = (roomScope, location, index, diagnostics) => {
+    if (!index.rooms.has(roomScope)) {
+        diagnostics.push({
+            level: "error",
+            message: `${location} references unknown room ${roomScope}`
+        });
+    }
+};
+const addDiagnosticsForScope = (scope, location, index, diagnostics) => {
+    const room = parseRoomScope(scope);
+    if (room) {
+        addMissingRoomDiagnostic(room, location, index, diagnostics);
+        return;
+    }
+    const agent = parseAgentScope(scope);
+    if (agent) {
+        addMissingAgentDiagnostic(agent, location, index, diagnostics);
+        return;
+    }
+    const team = parseTeamScope(scope);
+    if (team) {
+        addMissingTeamDiagnostic(team, location, index, diagnostics);
+        return;
+    }
+};
+const isEventNode = (value) => isRecord(value) && "event" in value;
+const validateConditionScopes = (location, value, index, diagnostics) => {
+    if (!isRecord(value)) {
+        return;
+    }
+    if ("all" in value) {
+        const children = value.all;
+        if (!Array.isArray(children)) {
+            return;
+        }
+        children.forEach((child) => {
+            validateConditionScopes(location, child, index, diagnostics);
+        });
+        return;
+    }
+    if ("any" in value) {
+        const children = value.any;
+        if (!Array.isArray(children)) {
+            return;
+        }
+        children.forEach((child) => {
+            validateConditionScopes(location, child, index, diagnostics);
+        });
+        return;
+    }
+    if ("not" in value) {
+        validateConditionScopes(location, value.not, index, diagnostics);
+        return;
+    }
+    if (isEventNode(value)) {
+        if (typeof value.target === "string") {
+            addDiagnosticsForScope(value.target, `${location} event target`, index, diagnostics);
+        }
+        if (typeof value.actor === "string") {
+            addDiagnosticsForScope(value.actor, `${location} event actor`, index, diagnostics);
+        }
+        if (typeof value.scope === "string" && value.scope !== "global") {
+            addDiagnosticsForScope(value.scope, `${location} event scope`, index, diagnostics);
+        }
+    }
+};
+const validateVariableScopes = (variableId, variable, index, diagnostics) => {
+    if (variable.scope !== "global") {
+        addDiagnosticsForScope(variable.scope, `variable "${variableId}" scope`, index, diagnostics);
+    }
+};
+const validateRuleAction = (ruleId, action, index, diagnostics) => {
+    if ("to" in action) {
+        addDiagnosticsForScope(action.to, `rule "${ruleId}" action ${action.action} target`, index, diagnostics);
+    }
+};
+const validateMarkerScopes = (markerId, markerScopes, index, diagnostics) => {
+    for (const scope of markerScopes ?? []) {
+        if (scope !== "global") {
+            addDiagnosticsForScope(scope, `marker "${markerId}" scope`, index, diagnostics);
+        }
+    }
+};
+const validateRule = (ruleId, rule, index, diagnostics) => {
+    validateConditionScopes(`rule "${ruleId}"`, rule.when, index, diagnostics);
+    rule.do.forEach((action) => {
+        validateRuleAction(ruleId, action, index, diagnostics);
+    });
+};
+const validateProbe = (probeId, probe, index, diagnostics) => {
+    validateConditionScopes(`probe "${probeId}"`, probe.when, index, diagnostics);
+    if (probe.after) {
+        validateConditionScopes(`probe "${probeId}" after`, probe.after, index, diagnostics);
+    }
+};
+export const createBindingDiagnostics = (simfile, report) => {
+    const diagnostics = [];
+    if (!report) {
+        return diagnostics;
+    }
+    const index = createReportScopeIndex(report);
+    for (const [variableId, variable] of Object.entries(simfile.variables)) {
+        validateVariableScopes(variableId, variable, index, diagnostics);
+    }
+    for (const [markerId, marker] of Object.entries(simfile.markers)) {
+        validateMarkerScopes(markerId, marker.scopes, index, diagnostics);
+    }
+    for (const [ruleId, rule] of Object.entries(simfile.rules)) {
+        validateRule(ruleId, rule, index, diagnostics);
+    }
+    for (const [probeId, probe] of Object.entries(simfile.probes)) {
+        validateProbe(probeId, probe, index, diagnostics);
+    }
+    return diagnostics;
+};
+export const parseSpawnfileReportJson = (reportJson) => {
+    let report;
+    try {
+        report = JSON.parse(reportJson);
+    }
+    catch (error) {
+        throw new Error(`Invalid Spawnfile report JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(report) && !Array.isArray(report)) {
+        throw new Error("Spawnfile report must be a JSON object");
+    }
+    return report;
+};
+export const loadSpawnfileReport = async (pathOrJson) => {
+    try {
+        return parseSpawnfileReportJson(pathOrJson);
+    }
+    catch (parseError) {
+        const reportText = await readFile(pathOrJson, "utf8");
+        try {
+            return parseSpawnfileReportJson(reportText);
+        }
+        catch (fileError) {
+            if (parseError instanceof Error) {
+                throw parseError;
+            }
+            throw fileError;
+        }
+    }
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./model.js";
+export * from "./parse.js";
+export * from "./semantic.js";
+export * from "./binding.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/dist/schema/index.js

@@ -0,0 +1,4 @@
+export * from "./model.js";
+export * from "./parse.js";
+export * from "./semantic.js";
+export * from "./binding.js";

package/dist/schema/model.d.ts

@@ -0,0 +1,244 @@
+import { z } from "zod";
+export declare const simfileIdentifierSchema: z.ZodString;
+export declare const simfileRangeSchema: z.ZodString;
+export declare const simfileEventKinds: readonly ["clock.sync", "rule.fired", "world.message", "world.dm", "world.act", "wake.recommended", "marker.seen"];
+export declare const simfileWhenSchema: z.ZodTypeAny;
+export declare const simfileClockSchema: z.ZodObject<{
+    seed: z.ZodString;
+    tick: z.ZodString;
+    sim_per_tick: z.ZodOptional<z.ZodString>;
+    phases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+declare const simfileVariableSchema: z.ZodObject<{
+    scope: z.ZodString;
+    initial: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodString;
+    measure: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            messages_in: "messages_in";
+            token_mentions: "token_mentions";
+            marker_violations: "marker_violations";
+            distinct_speakers: "distinct_speakers";
+            mentions_of: "mentions_of";
+            ticks_since_last_message: "ticks_since_last_message";
+        }>;
+        scope: z.ZodOptional<z.ZodString>;
+        window: z.ZodString;
+    }, z.core.$strict>>;
+    derive: z.ZodOptional<z.ZodObject<{
+        eq: z.ZodString;
+    }, z.core.$strict>>;
+    fed_by: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const simfileGeneratorSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"deterministic">;
+    when: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    variable: z.ZodString;
+    delta: z.ZodOptional<z.ZodNumber>;
+    delta_eq: z.ZodOptional<z.ZodString>;
+    set_eq: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stochastic">;
+    when: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    variable: z.ZodString;
+    uniform: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strict>]>;
+export declare const simfileRuleActionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"moltnet:message">;
+    to: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"moltnet:dm">;
+    to: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"wake:recommend">;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"variable:set">;
+    variable: z.ZodString;
+    value: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"variable:delta">;
+    variable: z.ZodString;
+    value: z.ZodNumber;
+}, z.core.$strict>]>;
+export declare const simfileRuleSchema: z.ZodObject<{
+    fire: z.ZodDefault<z.ZodEnum<{
+        once: "once";
+        per_crossing: "per_crossing";
+    }>>;
+    when: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    do: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        action: z.ZodLiteral<"moltnet:message">;
+        to: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"moltnet:dm">;
+        to: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"wake:recommend">;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"variable:set">;
+        variable: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"variable:delta">;
+        variable: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const simfileLedgerSchema: z.ZodObject<{
+    store: z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            jsonl: "jsonl";
+            sqlite: "sqlite";
+            postgres: "postgres";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const simfileTelemetrySchema: z.ZodObject<{
+    snapshot_every: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const simfileMarkerSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodEnum<{
+        containment: "containment";
+        propagation: "propagation";
+    }>;
+    scopes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const simfileProbeSchema: z.ZodObject<{
+    when: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    expect: z.ZodUnion<readonly [z.ZodObject<{
+        at_least: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        at_most: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        always: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        at_end: z.ZodLiteral<true>;
+    }, z.core.$strict>]>;
+    after: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    within: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const simfileSchema: z.ZodObject<{
+    simfile_version: z.ZodLiteral<"0.1">;
+    name: z.ZodString;
+    spawnfile: z.ZodOptional<z.ZodString>;
+    clock: z.ZodObject<{
+        seed: z.ZodString;
+        tick: z.ZodString;
+        sim_per_tick: z.ZodOptional<z.ZodString>;
+        phases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>;
+    variables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        scope: z.ZodString;
+        initial: z.ZodOptional<z.ZodNumber>;
+        range: z.ZodString;
+        measure: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                messages_in: "messages_in";
+                token_mentions: "token_mentions";
+                marker_violations: "marker_violations";
+                distinct_speakers: "distinct_speakers";
+                mentions_of: "mentions_of";
+                ticks_since_last_message: "ticks_since_last_message";
+            }>;
+            scope: z.ZodOptional<z.ZodString>;
+            window: z.ZodString;
+        }, z.core.$strict>>;
+        derive: z.ZodOptional<z.ZodObject<{
+            eq: z.ZodString;
+        }, z.core.$strict>>;
+        fed_by: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    generators: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"deterministic">;
+        when: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        variable: z.ZodString;
+        delta: z.ZodOptional<z.ZodNumber>;
+        delta_eq: z.ZodOptional<z.ZodString>;
+        set_eq: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"stochastic">;
+        when: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        variable: z.ZodString;
+        uniform: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strict>]>>>;
+    rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fire: z.ZodDefault<z.ZodEnum<{
+            once: "once";
+            per_crossing: "per_crossing";
+        }>>;
+        when: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        do: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            action: z.ZodLiteral<"moltnet:message">;
+            to: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"moltnet:dm">;
+            to: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"wake:recommend">;
+            to: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"variable:set">;
+            variable: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"variable:delta">;
+            variable: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    ledger: z.ZodOptional<z.ZodObject<{
+        store: z.ZodObject<{
+            kind: z.ZodDefault<z.ZodEnum<{
+                jsonl: "jsonl";
+                sqlite: "sqlite";
+                postgres: "postgres";
+            }>>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        snapshot_every: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    markers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        text: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodEnum<{
+            containment: "containment";
+            propagation: "propagation";
+        }>;
+        scopes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    probes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        when: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        expect: z.ZodUnion<readonly [z.ZodObject<{
+            at_least: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            at_most: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            always: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            at_end: z.ZodLiteral<true>;
+        }, z.core.$strict>]>;
+        after: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        within: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Simfile = z.infer<typeof simfileSchema>;
+export type SimfileClock = z.infer<typeof simfileClockSchema>;
+export type SimfileGenerator = z.infer<typeof simfileGeneratorSchema>;
+export type SimfileRule = z.infer<typeof simfileRuleSchema>;
+export type SimfileLedger = z.infer<typeof simfileLedgerSchema>;
+export type SimfileProbe = z.infer<typeof simfileProbeSchema>;
+export type SimfileRuleAction = z.infer<typeof simfileRuleActionSchema>;
+export type SimfileVariable = z.infer<typeof simfileVariableSchema>;
+export {};
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/schema/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB,aAElC,CAAC;AAMH,eAAO,MAAM,kBAAkB,aAY7B,CAAC;AAuBH,eAAO,MAAM,iBAAiB,oHAQpB,CAAC;AAwBX,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,UAW/B,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;;;kBAKpB,CAAC;AAYZ,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;kBAYhB,CAAC;AAuBZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;oBAGjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;oBAyBlC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAInB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;;;kBAKrB,CAAC;AAEZ,eAAO,MAAM,sBAAsB;;kBAExB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;kBAIrB,CAAC;AAkBZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;kBAoBpB,CAAC;AAEZ,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYf,CAAC;AAEZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}