@telorun/analyzer 0.44.0 → 0.46.0

package/dist/module-version-order.js

@@ -0,0 +1,91 @@
+/** SemVer precedence for module versions — the single ordering rule shared by
+ *  version reconciliation and by any host deciding whether an import is behind.
+ *
+ *  Pure and dependency-free (no `semver` package), so the analyzer stays
+ *  browser-safe and the editor can reach the same rule the kernel-side analysis
+ *  uses. A caller that cannot parse a version must not guess: an OCI digest, a
+ *  moving tag like `latest`, and a malformed pin all come back `null` rather
+ *  than being ordered by some weaker fallback. */
+/** Parse `X.Y.Z`, `vX.Y.Z`, or `X.Y.Z-pre.1`. Returns `null` for anything that
+ *  isn't a plain three-part numeric core — an unparseable version is never
+ *  silently ordered. */
+export function parseModuleVersion(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const v = raw.startsWith("v") ? raw.slice(1) : raw;
+    const [core, ...preParts] = v.split("-");
+    const pre = preParts.length > 0 ? preParts.join("-") : null;
+    const segments = core.split(".");
+    if (segments.length !== 3)
+        return null;
+    const [major, minor, patch] = segments.map((s) => {
+        if (!/^\d+$/.test(s))
+            return NaN;
+        return Number(s);
+    });
+    if ([major, minor, patch].some((n) => Number.isNaN(n)))
+        return null;
+    return { major, minor, patch, pre: pre === null ? null : pre.split(".") };
+}
+/** SemVer precedence: numeric core, then a release outranks a prerelease, then
+ *  prerelease identifiers compared field-by-field (numeric < non-numeric per
+ *  spec, shorter set loses when all shared fields are equal). */
+export function compareParsedModuleVersions(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    if (a.pre === null && b.pre === null)
+        return 0;
+    if (a.pre === null)
+        return 1;
+    if (b.pre === null)
+        return -1;
+    const len = Math.max(a.pre.length, b.pre.length);
+    for (let i = 0; i < len; i++) {
+        const ai = a.pre[i];
+        const bi = b.pre[i];
+        if (ai === undefined)
+            return -1;
+        if (bi === undefined)
+            return 1;
+        const an = /^\d+$/.test(ai);
+        const bn = /^\d+$/.test(bi);
+        if (an && bn) {
+            const d = Number(ai) - Number(bi);
+            if (d !== 0)
+                return d;
+        }
+        else if (an !== bn) {
+            return an ? -1 : 1;
+        }
+        else if (ai !== bi) {
+            return ai < bi ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/** Negative / zero / positive when both versions parse, `null` when either does
+ *  not. The string-in convenience over {@link compareParsedModuleVersions}. */
+export function compareModuleVersions(a, b) {
+    const left = parseModuleVersion(a);
+    const right = parseModuleVersion(b);
+    if (!left || !right)
+        return null;
+    return compareParsedModuleVersions(left, right);
+}
+/** True when `candidate` is strictly newer than `current` — the test for
+ *  whether an import is behind. False when they are equal, when `current` is
+ *  ahead (a version index can lag the module's own origin, and "upgrading" to
+ *  what it knows would be a downgrade), or when either side is unparseable. */
+export function isNewerModuleVersion(candidate, current) {
+    return (compareModuleVersions(candidate, current) ?? 0) > 0;
+}
+/** True when two tags name the same version, tolerating a `v` prefix on either
+ *  side. Falls back to exact equality for unparseable tags, so a digest still
+ *  matches itself. */
+export function isSameModuleVersion(a, b) {
+    return a === b || compareModuleVersions(a, b) === 0;
+}

package/dist/reconcile-module-versions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-module-versions.d.ts","sourceRoot":"","sources":["../src/reconcile-module-versions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE;;;;0CAI0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;2EACuE;IACvE,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC;AAuMD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAClC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAChD,qBAAqB,CAsEvB"}
+{"version":3,"file":"reconcile-module-versions.d.ts","sourceRoot":"","sources":["../src/reconcile-module-versions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOlE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE;;;;0CAI0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;2EACuE;IACvE,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC;AAgJD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAClC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAChD,qBAAqB,CAsEvB"}

package/dist/reconcile-module-versions.js

@@ -1,69 +1,7 @@
 import { isModuleKind } from "./module-kinds.js";
+import { compareParsedModuleVersions, parseModuleVersion, } from "./module-version-order.js";
 import { DiagnosticSeverity } from "./types.js";
 const SOURCE = "telo-analyzer";
-/** Parse `X.Y.Z`, `vX.Y.Z`, or `X.Y.Z-pre.1`. Returns `null` for anything that
- *  isn't a plain three-part numeric core — an unparseable version forces the
- *  group onto the conflict path (we never silently hoist across a version we
- *  can't reason about). Pure: no dependency on the `semver` package, so the
- *  analyzer stays browser-safe and dependency-free. */
-function parseVersion(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const v = raw.startsWith("v") ? raw.slice(1) : raw;
-    const [core, ...preParts] = v.split("-");
-    const pre = preParts.length > 0 ? preParts.join("-") : null;
-    const segments = core.split(".");
-    if (segments.length !== 3)
-        return null;
-    const [major, minor, patch] = segments.map((s) => {
-        if (!/^\d+$/.test(s))
-            return NaN;
-        return Number(s);
-    });
-    if ([major, minor, patch].some((n) => Number.isNaN(n)))
-        return null;
-    return { major, minor, patch, pre: pre === null ? null : pre.split(".") };
-}
-/** SemVer precedence: numeric core, then a release outranks a prerelease, then
- *  prerelease identifiers compared field-by-field (numeric < non-numeric per
- *  spec, shorter set loses when all shared fields are equal). */
-function compareVersions(a, b) {
-    if (a.major !== b.major)
-        return a.major - b.major;
-    if (a.minor !== b.minor)
-        return a.minor - b.minor;
-    if (a.patch !== b.patch)
-        return a.patch - b.patch;
-    if (a.pre === null && b.pre === null)
-        return 0;
-    if (a.pre === null)
-        return 1;
-    if (b.pre === null)
-        return -1;
-    const len = Math.max(a.pre.length, b.pre.length);
-    for (let i = 0; i < len; i++) {
-        const ai = a.pre[i];
-        const bi = b.pre[i];
-        if (ai === undefined)
-            return -1;
-        if (bi === undefined)
-            return 1;
-        const an = /^\d+$/.test(ai);
-        const bn = /^\d+$/.test(bi);
-        if (an && bn) {
-            const d = Number(ai) - Number(bi);
-            if (d !== 0)
-                return d;
-        }
-        else if (an !== bn) {
-            return an ? -1 : 1;
-        }
-        else if (ai !== bi) {
-            return ai < bi ? -1 : 1;
-        }
-    }
-    return 0;
-}
 /** The location identity of an import ref: the ref with its version stripped.
  *  Two refs share an identity when they address the same module at different
  *  versions, whatever transport owns them:
@@ -115,7 +53,7 @@ function moduleIdentityOf(mod, identity) {
         source: mod.owner.source,
         identity,
         version,
-        parsed: parseVersion(version),
+        parsed: parseModuleVersion(version),
         text: mod.owner.text,
     };
 }
@@ -135,7 +73,7 @@ function resolveGroup(members) {
             return best;
         if (!best.parsed)
             return cur;
-        const cmp = compareVersions(cur.parsed, best.parsed);
+        const cmp = compareParsedModuleVersions(cur.parsed, best.parsed);
         if (cmp > 0)
             return cur;
         if (cmp === 0 && cur.source < best.source)

package/dist/sources/versioned-ref.d.ts

@@ -0,0 +1,34 @@
+/** A module ref split into the parts an upgrade needs: the version-independent
+ *  ref, the version segment it currently names, and any inline pin. */
+export interface ParsedVersionedRef {
+    /** The ref with its `@version` segment and integrity fragment removed —
+     *  `std/run`, `oci://ghcr.io/telorun/timer`. This is the identity a version
+     *  list is keyed by (the hub registers modules under exactly this form). */
+    baseRef: string;
+    /** The version segment, raw — a registry `@version`, an OCI tag, or an OCI
+     *  digest reference (`sha256:…`). The caller applies its own SemVer check. */
+    version: string;
+    /** Telo's inline `sha256-<base64url>` pin, when the ref carried one. */
+    integrity?: string;
+}
+/** Split a versioned module ref. Returns `null` when the ref names no
+ *  upgradeable version — a local path, a bare `https://` URL, or an OCI ref
+ *  with no explicit reference (an implicit `latest` is not a pin).
+ *
+ *  Browser-safe and transport-neutral: this is the *grammar* half of an
+ *  upgrade, shared by the kernel transports (whose `refVersion` / `withVersion`
+ *  delegate here) and the editor, which cannot use a transport at all — the
+ *  *network* half (enumerating versions) is scheme-specific and stays behind
+ *  `Transport.listVersions` on Node and the hub's `/module/versions` in the
+ *  browser. */
+export declare function parseVersionedRef(ref: string): ParsedVersionedRef | null;
+/** `ref` rewritten to name `version`, dropping any integrity fragment (the
+ *  caller re-pins the result). Appends the version when the ref carries none —
+ *  an untagged `oci://host/repo` is still a versionable address.
+ *
+ *  Throws when the ref's grammar has no version segment at all — a relative
+ *  path, a bare `https://` URL. Producing `../lib@0.4.0` for those would write
+ *  a ref nothing can resolve, so this fails where the transport-specific
+ *  parsers it replaced (`parseOciRef` / `parseModuleRef`) also failed. */
+export declare function withRefVersion(ref: string, version: string): string;
+//# sourceMappingURL=versioned-ref.d.ts.map

package/dist/sources/versioned-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-ref.d.ts","sourceRoot":"","sources":["../../src/sources/versioned-ref.ts"],"names":[],"mappings":"AAIA;uEACuE;AACvE,MAAM,WAAW,kBAAkB;IACjC;;gFAE4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB;kFAC8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;eASe;AACf,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAOxE;AAED;;;;;;;0EAO0E;AAC1E,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUnE"}

package/dist/sources/versioned-ref.js

@@ -0,0 +1,60 @@
+import { splitIntegrity } from "./integrity.js";
+import { isRegistryRef } from "./module-ref.js";
+import { OCI_SCHEME } from "./oci-ref.js";
+/** Split a versioned module ref. Returns `null` when the ref names no
+ *  upgradeable version — a local path, a bare `https://` URL, or an OCI ref
+ *  with no explicit reference (an implicit `latest` is not a pin).
+ *
+ *  Browser-safe and transport-neutral: this is the *grammar* half of an
+ *  upgrade, shared by the kernel transports (whose `refVersion` / `withVersion`
+ *  delegate here) and the editor, which cannot use a transport at all — the
+ *  *network* half (enumerating versions) is scheme-specific and stays behind
+ *  `Transport.listVersions` on Node and the hub's `/module/versions` in the
+ *  browser. */
+export function parseVersionedRef(ref) {
+    const { base, integrity } = splitIntegrity(ref);
+    const at = versionSeparator(base);
+    if (at === null)
+        return null;
+    const version = base.slice(at + 1);
+    if (!version)
+        return null;
+    return { baseRef: base.slice(0, at), version, integrity };
+}
+/** `ref` rewritten to name `version`, dropping any integrity fragment (the
+ *  caller re-pins the result). Appends the version when the ref carries none —
+ *  an untagged `oci://host/repo` is still a versionable address.
+ *
+ *  Throws when the ref's grammar has no version segment at all — a relative
+ *  path, a bare `https://` URL. Producing `../lib@0.4.0` for those would write
+ *  a ref nothing can resolve, so this fails where the transport-specific
+ *  parsers it replaced (`parseOciRef` / `parseModuleRef`) also failed. */
+export function withRefVersion(ref, version) {
+    const { base } = splitIntegrity(ref);
+    if (refGrammar(base) === null) {
+        throw new Error(`Cannot set a version on '${ref}' — only registry (namespace/name@version) ` +
+            `and oci:// refs carry a version segment.`);
+    }
+    const at = versionSeparator(base);
+    return `${at === null ? base : base.slice(0, at)}@${version}`;
+}
+/** Which versionable ref grammar `base` is written in, or `null` when it is
+ *  neither — a relative/absolute path, a `file:`/`https://` URL. */
+function refGrammar(base) {
+    if (base.startsWith(OCI_SCHEME)) {
+        // A host alone is not addressable; the repo path is what carries a version.
+        return base.indexOf("/", OCI_SCHEME.length) > OCI_SCHEME.length ? "oci" : null;
+    }
+    // `isRegistryRef` requires the `@`, so a version-less `std/console` is not a
+    // registry ref by this test — matching `parseModuleRef`, which throws on it.
+    return isRegistryRef(base) ? "registry" : null;
+}
+/** Index of the `@` that separates the version, or `null` when the ref names
+ *  none. Split on the LAST `@` so a digest reference (`repo@sha256:…`) keeps
+ *  everything before it as the ref. */
+function versionSeparator(base) {
+    if (refGrammar(base) === null)
+        return null;
+    const at = base.lastIndexOf("@");
+    return at > (base.startsWith(OCI_SCHEME) ? OCI_SCHEME.length : 0) ? at : null;
+}

package/dist/validate-observed-state.d.ts

@@ -0,0 +1,98 @@
+import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
+import { type ModuleScopes } from "./alias-resolver.js";
+/**
+ * The `status:` block's own schema — a plain JSON Schema, structurally. The one
+ * normative restriction (`required:` is rejected) is enforced by
+ * {@link validateObservedStateDeclarations} rather than here, so the author gets
+ * a message naming the rule and the fix instead of AJV's "must NOT be valid".
+ *
+ * Exported from the analyzer and re-used by the kernel's manifest schemas, so
+ * the rule has one definition rather than two kept in sync by hand.
+ */
+export declare const OBSERVED_STATE_SCHEMA: {
+    type: string;
+    additionalProperties: boolean;
+};
+/**
+ * `required:` inside a `status:` block. Every declared field is mandatory once
+ * the resource has run, so the list would be either redundant or a lie; a
+ * genuinely sometimes-absent value is declared with a nullable type, which
+ * `CEL_NULLABLE_ACCESS` already guards.
+ */
+export declare function validateObservedStateDeclarations(manifests: readonly ResourceManifest[]): Array<{
+    kind: string;
+    name: string;
+    filePath?: string;
+    message: string;
+}>;
+/** A CEL access into a resource's observed-state segment. */
+export interface ObservedStateRead {
+    /** Import alias, when the read crosses a module boundary
+     *  (`resources.<Alias>.<name>.status`). */
+    alias?: string;
+    /** Resource name. */
+    name: string;
+    /** The field read under `.status`, when the chain names one. */
+    field?: string;
+}
+/**
+ * Recognise an observed-state read in a member-access chain. Purely syntactic —
+ * it inspects the chain, not the topology — so the availability rule it feeds
+ * applies to every kind, declared or not.
+ *
+ * `resources.<name>.status.<field>` and the two-level cross-module form
+ * `resources.<Alias>.<name>.status.<field>` are both observed-state reads.
+ */
+export declare function observedStateRead(chain: readonly string[]): ObservedStateRead | undefined;
+/**
+ * The names of every resource some slot can start: referenced from a ref slot
+ * that accepts a `Telo.Runnable` / `Telo.Service`, or named as a step's
+ * `invoke:` target. A resource in none of them can never `run()`, so it can
+ * never report observed state.
+ *
+ * Deliberately an over-approximation — a name reachable through any of these
+ * routes counts as runnable — because the cost of a false "can never run" is a
+ * valid manifest rejected, while the cost of a miss is only that the reader
+ * finds out at runtime instead, with a message that names the same fix.
+ */
+export declare function collectRunReachableNames(manifests: readonly ResourceManifest[], defs: {
+    resolve(kind: string): ResourceDefinition | undefined;
+}, aliases?: {
+    resolveKind(kind: string): string | undefined;
+}): Set<string>;
+/** What a resource name resolves to for CEL purposes. `status` is present only
+ *  when the kind declares one; `scoped` marks a resource declared inside an
+ *  `x-telo-scope` slot, which resolves only within that scope's regions. */
+export interface AnalyzedResource {
+    kind: string;
+    status?: Record<string, any>;
+    scoped?: boolean;
+}
+/**
+ * Index every resource a CEL `resources.…` read can name: the module's own
+ * top-level resources, the ones declared inside `x-telo-scope` slots (a
+ * `Run.Sequence`'s `with:`), and each import's exported instances — keyed
+ * `<Alias>.<name>`, the two-level shape those publish under.
+ *
+ * Scope slots are found through the declaring kind's schema annotation, not by
+ * field name, so any composer with a scope participates.
+ */
+export declare function buildObservedStateIndex(manifests: readonly ResourceManifest[], defs: {
+    resolve(kind: string): ResourceDefinition | undefined;
+}, aliases?: {
+    resolveKind(kind: string): string | undefined;
+    moduleForAlias?(alias: string): string | undefined;
+}, scopes?: ModuleScopes): Map<string, AnalyzedResource>;
+/** The `resources` node of a CEL context schema: one entry per resource, each
+ *  open except for a typed, closed `status` node on kinds that declare one.
+ *  `open` keeps the map itself permissive, so unknown resource names and every
+ *  flat field pass exactly as they do today. */
+export declare function buildObservedStateResourcesSchema(index: ReadonlyMap<string, AnalyzedResource>, open: boolean): Record<string, any>;
+/**
+ * Write the typed `status` node for one index key into a `resources` property
+ * map. A dotted key (`Alias.name`) is an import's exported instance, which
+ * publishes two levels deep — the alias node stays open so every other name
+ * under it keeps resolving as it does today.
+ */
+export declare function applyObservedStateNode(properties: Record<string, any>, key: string, status: Record<string, any>): void;
+//# sourceMappingURL=validate-observed-state.d.ts.map

package/dist/validate-observed-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-observed-state.d.ts","sourceRoot":"","sources":["../src/validate-observed-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAyBjF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;CAGjC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,SAAS,gBAAgB,EAAE,GACrC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC;+CAC2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAOzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,IAAI,EAAE;IAAE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;CAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,GAC1D,GAAG,CAAC,MAAM,CAAC,CAyBb;AAgDD;;4EAE4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,IAAI,EAAE;IAAE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;CAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAAC,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,EAC/G,MAAM,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAsC/B;AAyDD;;;gDAGgD;AAChD,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC5C,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAmBN"}