@stevenvo780/st-lang 4.8.0 → 4.10.0

package/dist/type-theory/effects/core.js

@@ -0,0 +1,79 @@
+"use strict";
+// ============================================================
+// Algebraic effects — Constructores y combinadores del free monad
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pure = pure;
+exports.perform = perform;
+exports.bind = bind;
+exports.map = map;
+exports.sequence = sequence;
+exports.handle = handle;
+exports.run = run;
+/** Inyecta un valor puro en la mónada. */
+function pure(value) {
+    return { kind: 'pure', value };
+}
+/**
+ * Construye una computación que ejecuta una operación `tag` con `input`
+ * y entrega su resultado al consumidor. La continuación es la identidad:
+ * "haz la operación y devuelve su salida".
+ */
+function perform(tag, input) {
+    return {
+        kind: 'impure',
+        effect: { tag, input },
+        // El runtime garantiza que `value` es `O`; lo elevamos a través del tipo.
+        continuation: (value) => pure(value),
+    };
+}
+/** Bind monádico (>>= en notación de Haskell). */
+function bind(eff, fn) {
+    if (eff.kind === 'pure')
+        return fn(eff.value);
+    // Componemos la continuación con `fn` para extender el árbol.
+    const k = eff.continuation;
+    return {
+        kind: 'impure',
+        effect: eff.effect,
+        continuation: (value) => bind(k(value), fn),
+    };
+}
+/** Alias funtorial: aplica una función pura al resultado. */
+function map(eff, fn) {
+    return bind(eff, (a) => pure(fn(a)));
+}
+/** Secuencia una lista de computaciones y colecta sus resultados. */
+function sequence(effs) {
+    return effs.reduce((acc, cur) => bind(acc, (xs) => bind(cur, (x) => pure([...xs, x]))), pure([]));
+}
+/**
+ * Interpreta un efecto concreto. Recorre el árbol: las hojas `pure`
+ * pasan tal cual; los nodos `impure` cuyo `tag` coincida con el
+ * handler son delegados a `handle`; el resto se propaga.
+ */
+function handle(eff, handler) {
+    if (eff.kind === 'pure')
+        return pure(eff.value);
+    if (eff.effect.tag === handler.effect) {
+        return handler.handle(eff.effect.input, (value) => handle(eff.continuation(value), handler));
+    }
+    // Efecto distinto: reconstruimos el nodo dejando intacta su operación,
+    // pero envolvemos recursivamente la continuación para que siga viendo
+    // este handler aguas abajo.
+    return {
+        kind: 'impure',
+        effect: eff.effect,
+        continuation: (value) => handle(eff.continuation(value), handler),
+    };
+}
+/**
+ * Extrae el valor de una computación 100% pura. Lanza si quedan efectos
+ * sin interpretar — útil tras componer todos los handlers.
+ */
+function run(eff) {
+    if (eff.kind === 'pure')
+        return eff.value;
+    throw new Error(`[effects] efecto sin manejar: ${eff.effect.tag}`);
+}
+//# sourceMappingURL=core.js.map

package/dist/type-theory/effects/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/type-theory/effects/core.ts"],"names":[],"mappings":"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"}

package/dist/type-theory/effects/exception.d.ts

@@ -0,0 +1,18 @@
+import type { Eff, Effect, ExceptionResult } from './types';
+export declare const EXCEPTION_THROW: "Exception.throw";
+export type ExceptionThrow<E> = Effect<typeof EXCEPTION_THROW, E, never>;
+export type Exception<E> = ExceptionThrow<E>;
+/** Lanza una excepción algebraica. La continuación se descarta. */
+export declare function throw_<E>(error: E): Eff<ExceptionThrow<E>, never>;
+/**
+ * Intérprete componible. Si el cómputo lanza, corta el árbol y emite
+ * `{ kind: 'error', error }`. Si finaliza puro, emite `{ kind: 'ok', value }`.
+ * Otros efectos se propagan tal cual.
+ */
+export declare function handleException<R, E, A>(eff: Eff<unknown, A>): Eff<R, ExceptionResult<E, A>>;
+/**
+ * Intérprete terminal: ejecuta el cómputo y captura una eventual
+ * excepción. Lanza si encuentra otra operación sin manejar.
+ */
+export declare function runException<E, A>(eff: Eff<unknown, A>): ExceptionResult<E, A>;
+//# sourceMappingURL=exception.d.ts.map

package/dist/type-theory/effects/exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/exception.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE5D,eAAO,MAAM,eAAe,EAAG,iBAA0B,CAAC;AAE1D,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,eAAe,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;AAE7C,mEAAmE;AACnE,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAc5F;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAU9E"}

package/dist/type-theory/effects/exception.js

@@ -0,0 +1,59 @@
+"use strict";
+// ============================================================
+// Effect: Exception<E>
+// ============================================================
+//
+// Una sola operación:
+//   - Exception.throw : E → never
+//
+// La continuación nunca se invoca: tirar aborta el cómputo y
+// `runException` devuelve `{ kind: 'error', error }`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCEPTION_THROW = void 0;
+exports.throw_ = throw_;
+exports.handleException = handleException;
+exports.runException = runException;
+const core_1 = require("./core");
+exports.EXCEPTION_THROW = 'Exception.throw';
+/** Lanza una excepción algebraica. La continuación se descarta. */
+function throw_(error) {
+    return (0, core_1.perform)(exports.EXCEPTION_THROW, error);
+}
+/**
+ * Intérprete componible. Si el cómputo lanza, corta el árbol y emite
+ * `{ kind: 'error', error }`. Si finaliza puro, emite `{ kind: 'ok', value }`.
+ * Otros efectos se propagan tal cual.
+ */
+function handleException(eff) {
+    function go(node) {
+        if (node.kind === 'pure')
+            return (0, core_1.pure)({ kind: 'ok', value: node.value });
+        const op = node.effect;
+        if (op.tag === exports.EXCEPTION_THROW) {
+            return (0, core_1.pure)({ kind: 'error', error: op.input });
+        }
+        return {
+            kind: 'impure',
+            effect: op,
+            continuation: (value) => go(node.continuation(value)),
+        };
+    }
+    return go(eff);
+}
+/**
+ * Intérprete terminal: ejecuta el cómputo y captura una eventual
+ * excepción. Lanza si encuentra otra operación sin manejar.
+ */
+function runException(eff) {
+    const node = eff;
+    for (;;) {
+        if (node.kind === 'pure')
+            return { kind: 'ok', value: node.value };
+        const op = node.effect;
+        if (op.tag === exports.EXCEPTION_THROW) {
+            return { kind: 'error', error: op.input };
+        }
+        throw new Error(`[runException] efecto no soportado: ${op.tag}`);
+    }
+}
+//# sourceMappingURL=exception.js.map

package/dist/type-theory/effects/exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.js","sourceRoot":"","sources":["../../../src/type-theory/effects/exception.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uBAAuB;AACvB,+DAA+D;AAC/D,EAAE;AACF,sBAAsB;AACtB,kCAAkC;AAClC,EAAE;AACF,6DAA6D;AAC7D,sDAAsD;;;AAWtD,wBAEC;AAOD,0CAcC;AAMD,oCAUC;AAhDD,iCAAuC;AAG1B,QAAA,eAAe,GAAG,iBAA0B,CAAC;AAK1D,mEAAmE;AACnE,SAAgB,MAAM,CAAI,KAAQ;IAChC,OAAO,IAAA,cAAO,EAAmC,uBAAe,EAAE,KAAK,CAAC,CAAC;AAC3E,CAAC;AAED;;;;GAIG;AACH,SAAgB,eAAe,CAAU,GAAoB;IAC3D,SAAS,EAAE,CAAC,IAAqB;QAC/B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,IAAA,WAAI,EAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACzE,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,GAAG,KAAK,uBAAe,EAAE,CAAC;YAC/B,OAAO,IAAA,WAAI,EAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAU,EAAE,CAAC,CAAC;QACvD,CAAC;QACD,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE,EAAE;YACV,YAAY,EAAE,CAAC,KAAY,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SAC7D,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAO,GAAoB;IACrD,MAAM,IAAI,GAAG,GAAG,CAAC;IACjB,SAAS,CAAC;QACR,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;QACnE,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,GAAG,KAAK,uBAAe,EAAE,CAAC;YAC/B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,KAAU,EAAE,CAAC;QACjD,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,uCAAuC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACnE,CAAC;AACH,CAAC"}

package/dist/type-theory/effects/index.d.ts

@@ -0,0 +1,11 @@
+export type { Eff, Effect, Handler, Operation, Monoid, ExceptionResult } from './types';
+export { pure, perform, bind, map, sequence, handle, run } from './core';
+export { STATE_GET, STATE_PUT, getState, putState, modify, runState, handleState } from './state';
+export type { State, StateGet, StatePut } from './state';
+export { READER_ASK, ask, asks, runReader, handleReader } from './reader';
+export type { Reader, ReaderAsk } from './reader';
+export { WRITER_TELL, tell, runWriter, handleWriter, listMonoid, stringMonoid, sumMonoid, } from './writer';
+export type { Writer, WriterTell } from './writer';
+export { EXCEPTION_THROW, throw_, runException, handleException } from './exception';
+export type { Exception, ExceptionThrow } from './exception';
+//# sourceMappingURL=index.d.ts.map

package/dist/type-theory/effects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/index.ts"],"names":[],"mappings":"AAYA,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAExF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAClG,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC1E,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAElD,OAAO,EACL,WAAW,EACX,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,SAAS,GACV,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACrF,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/type-theory/effects/index.js

@@ -0,0 +1,50 @@
+"use strict";
+// ============================================================
+// Algebraic effects + free monads — Punto de entrada público
+// ============================================================
+//
+// API:
+//   - Núcleo: pure / perform / bind / map / sequence / handle / run
+//   - Estados: getState / putState / modify / runState / handleState
+//   - Reader:  ask / asks / runReader / handleReader
+//   - Writer:  tell / runWriter / handleWriter (+ monoides: listMonoid,
+//                                                stringMonoid, sumMonoid)
+//   - Exception: throw_ / runException / handleException
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleException = exports.runException = exports.throw_ = exports.EXCEPTION_THROW = exports.sumMonoid = exports.stringMonoid = exports.listMonoid = exports.handleWriter = exports.runWriter = exports.tell = exports.WRITER_TELL = exports.handleReader = exports.runReader = exports.asks = exports.ask = exports.READER_ASK = exports.handleState = exports.runState = exports.modify = exports.putState = exports.getState = exports.STATE_PUT = exports.STATE_GET = exports.run = exports.handle = exports.sequence = exports.map = exports.bind = exports.perform = exports.pure = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "pure", { enumerable: true, get: function () { return core_1.pure; } });
+Object.defineProperty(exports, "perform", { enumerable: true, get: function () { return core_1.perform; } });
+Object.defineProperty(exports, "bind", { enumerable: true, get: function () { return core_1.bind; } });
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return core_1.map; } });
+Object.defineProperty(exports, "sequence", { enumerable: true, get: function () { return core_1.sequence; } });
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return core_1.handle; } });
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "STATE_GET", { enumerable: true, get: function () { return state_1.STATE_GET; } });
+Object.defineProperty(exports, "STATE_PUT", { enumerable: true, get: function () { return state_1.STATE_PUT; } });
+Object.defineProperty(exports, "getState", { enumerable: true, get: function () { return state_1.getState; } });
+Object.defineProperty(exports, "putState", { enumerable: true, get: function () { return state_1.putState; } });
+Object.defineProperty(exports, "modify", { enumerable: true, get: function () { return state_1.modify; } });
+Object.defineProperty(exports, "runState", { enumerable: true, get: function () { return state_1.runState; } });
+Object.defineProperty(exports, "handleState", { enumerable: true, get: function () { return state_1.handleState; } });
+var reader_1 = require("./reader");
+Object.defineProperty(exports, "READER_ASK", { enumerable: true, get: function () { return reader_1.READER_ASK; } });
+Object.defineProperty(exports, "ask", { enumerable: true, get: function () { return reader_1.ask; } });
+Object.defineProperty(exports, "asks", { enumerable: true, get: function () { return reader_1.asks; } });
+Object.defineProperty(exports, "runReader", { enumerable: true, get: function () { return reader_1.runReader; } });
+Object.defineProperty(exports, "handleReader", { enumerable: true, get: function () { return reader_1.handleReader; } });
+var writer_1 = require("./writer");
+Object.defineProperty(exports, "WRITER_TELL", { enumerable: true, get: function () { return writer_1.WRITER_TELL; } });
+Object.defineProperty(exports, "tell", { enumerable: true, get: function () { return writer_1.tell; } });
+Object.defineProperty(exports, "runWriter", { enumerable: true, get: function () { return writer_1.runWriter; } });
+Object.defineProperty(exports, "handleWriter", { enumerable: true, get: function () { return writer_1.handleWriter; } });
+Object.defineProperty(exports, "listMonoid", { enumerable: true, get: function () { return writer_1.listMonoid; } });
+Object.defineProperty(exports, "stringMonoid", { enumerable: true, get: function () { return writer_1.stringMonoid; } });
+Object.defineProperty(exports, "sumMonoid", { enumerable: true, get: function () { return writer_1.sumMonoid; } });
+var exception_1 = require("./exception");
+Object.defineProperty(exports, "EXCEPTION_THROW", { enumerable: true, get: function () { return exception_1.EXCEPTION_THROW; } });
+Object.defineProperty(exports, "throw_", { enumerable: true, get: function () { return exception_1.throw_; } });
+Object.defineProperty(exports, "runException", { enumerable: true, get: function () { return exception_1.runException; } });
+Object.defineProperty(exports, "handleException", { enumerable: true, get: function () { return exception_1.handleException; } });
+//# sourceMappingURL=index.js.map

package/dist/type-theory/effects/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/type-theory/effects/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,6DAA6D;AAC7D,+DAA+D;AAC/D,EAAE;AACF,OAAO;AACP,oEAAoE;AACpE,qEAAqE;AACrE,qDAAqD;AACrD,wEAAwE;AACxE,0EAA0E;AAC1E,yDAAyD;;;AAIzD,+BAAyE;AAAhE,4FAAA,IAAI,OAAA;AAAE,+FAAA,OAAO,OAAA;AAAE,4FAAA,IAAI,OAAA;AAAE,2FAAA,GAAG,OAAA;AAAE,gGAAA,QAAQ,OAAA;AAAE,8FAAA,MAAM,OAAA;AAAE,2FAAA,GAAG,OAAA;AAExD,iCAAkG;AAAzF,kGAAA,SAAS,OAAA;AAAE,kGAAA,SAAS,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,+FAAA,MAAM,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,oGAAA,WAAW,OAAA;AAGhF,mCAA0E;AAAjE,oGAAA,UAAU,OAAA;AAAE,6FAAA,GAAG,OAAA;AAAE,8FAAA,IAAI,OAAA;AAAE,mGAAA,SAAS,OAAA;AAAE,sGAAA,YAAY,OAAA;AAGvD,mCAQkB;AAPhB,qGAAA,WAAW,OAAA;AACX,8FAAA,IAAI,OAAA;AACJ,mGAAA,SAAS,OAAA;AACT,sGAAA,YAAY,OAAA;AACZ,oGAAA,UAAU,OAAA;AACV,sGAAA,YAAY,OAAA;AACZ,mGAAA,SAAS,OAAA;AAIX,yCAAqF;AAA5E,4GAAA,eAAe,OAAA;AAAE,mGAAA,MAAM,OAAA;AAAE,yGAAA,YAAY,OAAA;AAAE,4GAAA,eAAe,OAAA"}

package/dist/type-theory/effects/reader.d.ts

@@ -0,0 +1,20 @@
+import type { Eff, Effect } from './types';
+export declare const READER_ASK: "Reader.ask";
+export type ReaderAsk<R> = Effect<typeof READER_ASK, void, R>;
+export type Reader<R> = ReaderAsk<R>;
+/** Lee el ambiente del Reader. */
+export declare function ask<R>(): Eff<ReaderAsk<R>, R>;
+/** Lee el ambiente y aplica una proyección. */
+export declare function asks<R, A>(fn: (r: R) => A): Eff<ReaderAsk<R>, A>;
+/**
+ * Intérprete componible. Reescribe `Reader.ask` proyectando el `env`
+ * fijo y deja otros efectos intactos.
+ */
+export declare function handleReader<R, A, Env>(eff: Eff<unknown, A>, env: Env): Eff<R, A>;
+/**
+ * Intérprete terminal: ejecuta el cómputo con un ambiente fijo.
+ * Cualquier `Reader.ask` recibe el mismo `env`. Lanza si encuentra
+ * otra operación sin manejar.
+ */
+export declare function runReader<R, A>(eff: Eff<unknown, A>, env: R): A;
+//# sourceMappingURL=reader.d.ts.map

package/dist/type-theory/effects/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/reader.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,UAAU,EAAG,YAAqB,CAAC;AAEhD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AAC9D,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;AAErC,kCAAkC;AAClC,wBAAgB,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAE7C;AAED,+CAA+C;AAC/C,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAEhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAcjF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAW/D"}

package/dist/type-theory/effects/reader.js

@@ -0,0 +1,62 @@
+"use strict";
+// ============================================================
+// Effect: Reader<R>
+// ============================================================
+//
+// Una sola operación:
+//   - Reader.ask : () → R
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READER_ASK = void 0;
+exports.ask = ask;
+exports.asks = asks;
+exports.handleReader = handleReader;
+exports.runReader = runReader;
+const core_1 = require("./core");
+exports.READER_ASK = 'Reader.ask';
+/** Lee el ambiente del Reader. */
+function ask() {
+    return (0, core_1.perform)(exports.READER_ASK, undefined);
+}
+/** Lee el ambiente y aplica una proyección. */
+function asks(fn) {
+    return (0, core_1.bind)(ask(), (r) => (0, core_1.pure)(fn(r)));
+}
+/**
+ * Intérprete componible. Reescribe `Reader.ask` proyectando el `env`
+ * fijo y deja otros efectos intactos.
+ */
+function handleReader(eff, env) {
+    function go(node) {
+        if (node.kind === 'pure')
+            return (0, core_1.pure)(node.value);
+        const op = node.effect;
+        if (op.tag === exports.READER_ASK) {
+            return go(node.continuation(env));
+        }
+        return {
+            kind: 'impure',
+            effect: op,
+            continuation: (value) => go(node.continuation(value)),
+        };
+    }
+    return go(eff);
+}
+/**
+ * Intérprete terminal: ejecuta el cómputo con un ambiente fijo.
+ * Cualquier `Reader.ask` recibe el mismo `env`. Lanza si encuentra
+ * otra operación sin manejar.
+ */
+function runReader(eff, env) {
+    let node = eff;
+    for (;;) {
+        if (node.kind === 'pure')
+            return node.value;
+        const op = node.effect;
+        if (op.tag === exports.READER_ASK) {
+            node = node.continuation(env);
+            continue;
+        }
+        throw new Error(`[runReader] efecto no soportado: ${op.tag}`);
+    }
+}
+//# sourceMappingURL=reader.js.map

package/dist/type-theory/effects/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.js","sourceRoot":"","sources":["../../../src/type-theory/effects/reader.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,oBAAoB;AACpB,+DAA+D;AAC/D,EAAE;AACF,sBAAsB;AACtB,0BAA0B;;;AAW1B,kBAEC;AAGD,oBAEC;AAMD,oCAcC;AAOD,8BAWC;AAtDD,iCAA6C;AAGhC,QAAA,UAAU,GAAG,YAAqB,CAAC;AAKhD,kCAAkC;AAClC,SAAgB,GAAG;IACjB,OAAO,IAAA,cAAO,EAA6B,kBAAU,EAAE,SAAS,CAAC,CAAC;AACpE,CAAC;AAED,+CAA+C;AAC/C,SAAgB,IAAI,CAAO,EAAe;IACxC,OAAO,IAAA,WAAI,EAAqB,GAAG,EAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,WAAI,EAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAY,GAAoB,EAAE,GAAQ;IACpE,SAAS,EAAE,CAAC,IAAqB;QAC/B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,IAAA,WAAI,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,GAAG,KAAK,kBAAU,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,GAAY,CAAC,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE,EAAE;YACV,YAAY,EAAE,CAAC,KAAY,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SAC7D,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAO,GAAoB,EAAE,GAAM;IAC1D,IAAI,IAAI,GAAG,GAAG,CAAC;IACf,SAAS,CAAC;QACR,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC;QAC5C,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,GAAG,KAAK,kBAAU,EAAE,CAAC;YAC1B,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,GAAY,CAAC,CAAC;YACvC,SAAS;QACX,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,oCAAoC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAChE,CAAC;AACH,CAAC"}

package/dist/type-theory/effects/state.d.ts

@@ -0,0 +1,31 @@
+import type { Eff, Effect } from './types';
+export declare const STATE_GET: "State.get";
+export declare const STATE_PUT: "State.put";
+export type StateGet<S> = Effect<typeof STATE_GET, void, S>;
+export type StatePut<S> = Effect<typeof STATE_PUT, S, undefined>;
+export type State<S> = StateGet<S> | StatePut<S>;
+/** Lee el estado actual. */
+export declare function getState<S>(): Eff<StateGet<S>, S>;
+/** Sobrescribe el estado completo. */
+export declare function putState<S>(s: S): Eff<StatePut<S>, undefined>;
+/** Modifica el estado aplicando una función pura. */
+export declare function modify<S>(fn: (s: S) => S): Eff<State<S>, undefined>;
+/**
+ * Intérprete componible. Reescribe `State.get`/`State.put` en términos
+ * de un acumulador transportado por la continuación, dejando otros
+ * efectos intactos en la salida.
+ */
+export declare function handleState<R, S, A>(eff: Eff<unknown, A>, initial: S): Eff<R, {
+    result: A;
+    state: S;
+}>;
+/**
+ * Intérprete terminal: ejecuta el cómputo asumiendo que sólo tiene
+ * efectos State. Devuelve `{ result, state }`. Lanza si encuentra
+ * otra operación sin manejar.
+ */
+export declare function runState<S, A>(eff: Eff<unknown, A>, initial: S): {
+    result: A;
+    state: S;
+};
+//# sourceMappingURL=state.d.ts.map

package/dist/type-theory/effects/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/state.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,SAAS,EAAG,WAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,EAAG,WAAoB,CAAC;AAE9C,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AAC5D,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;AACjE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEjD,4BAA4B;AAC5B,wBAAgB,QAAQ,CAAC,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAEjD;AAED,sCAAsC;AACtC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAE7D;AAED,qDAAqD;AACrD,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACjC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,GACT,GAAG,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC,CAoBjC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAiBxF"}

package/dist/type-theory/effects/state.js

@@ -0,0 +1,91 @@
+"use strict";
+// ============================================================
+// Effect: State<S>
+// ============================================================
+//
+// Dos operaciones canónicas:
+//   - State.get  : ()  → S      (lee el estado actual)
+//   - State.put  : S   → undefined (sobrescribe el estado)
+//
+// `modify` se deriva como get >>= (s -> put (fn s)).
+//
+// Dos formas de interpretar:
+//   - `runState`        : intérprete terminal. Devuelve {result, state}.
+//                         Útil cuando State es el único efecto.
+//   - `handleState`     : intérprete componible. Transforma
+//                         Eff<State<S> | R, A> en Eff<R, [A, S]>.
+//                         Útil para stack de efectos.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_PUT = exports.STATE_GET = void 0;
+exports.getState = getState;
+exports.putState = putState;
+exports.modify = modify;
+exports.handleState = handleState;
+exports.runState = runState;
+const core_1 = require("./core");
+exports.STATE_GET = 'State.get';
+exports.STATE_PUT = 'State.put';
+/** Lee el estado actual. */
+function getState() {
+    return (0, core_1.perform)(exports.STATE_GET, undefined);
+}
+/** Sobrescribe el estado completo. */
+function putState(s) {
+    return (0, core_1.perform)(exports.STATE_PUT, s);
+}
+/** Modifica el estado aplicando una función pura. */
+function modify(fn) {
+    return (0, core_1.bind)(getState(), (s) => putState(fn(s)));
+}
+/**
+ * Intérprete componible. Reescribe `State.get`/`State.put` en términos
+ * de un acumulador transportado por la continuación, dejando otros
+ * efectos intactos en la salida.
+ */
+function handleState(eff, initial) {
+    // Helper recursivo: dado un estado actual, reescribe el árbol.
+    function go(node, current) {
+        if (node.kind === 'pure')
+            return (0, core_1.pure)({ result: node.value, state: current });
+        const op = node.effect;
+        if (op.tag === exports.STATE_GET) {
+            return go(node.continuation(current), current);
+        }
+        if (op.tag === exports.STATE_PUT) {
+            const next = op.input;
+            return go(node.continuation(undefined), next);
+        }
+        // Otro efecto: lo dejamos pasar, propagando el estado en la cont.
+        return {
+            kind: 'impure',
+            effect: op,
+            continuation: (value) => go(node.continuation(value), current),
+        };
+    }
+    return go(eff, initial);
+}
+/**
+ * Intérprete terminal: ejecuta el cómputo asumiendo que sólo tiene
+ * efectos State. Devuelve `{ result, state }`. Lanza si encuentra
+ * otra operación sin manejar.
+ */
+function runState(eff, initial) {
+    let current = initial;
+    let node = eff;
+    for (;;) {
+        if (node.kind === 'pure')
+            return { result: node.value, state: current };
+        const op = node.effect;
+        if (op.tag === exports.STATE_GET) {
+            node = node.continuation(current);
+            continue;
+        }
+        if (op.tag === exports.STATE_PUT) {
+            current = op.input;
+            node = node.continuation(undefined);
+            continue;
+        }
+        throw new Error(`[runState] efecto no soportado: ${op.tag}`);
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/type-theory/effects/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../src/type-theory/effects/state.ts"],"names":[],"mappings":"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"}

package/dist/type-theory/effects/types.d.ts

@@ -0,0 +1,45 @@
+/** Firma de un efecto algebraico: nombre, payload, resultado esperado. */
+export type Effect<Name extends string, In, Out> = {
+    readonly tag: Name;
+    readonly input: In;
+    /** Phantom: usado sólo a nivel de tipos para inferir la respuesta. */
+    readonly output: Out;
+};
+/** Operación cruda almacenada en un nodo `impure`. */
+export interface Operation {
+    readonly tag: string;
+    readonly input: unknown;
+}
+/** Computación con efectos `E` y resultado `A`. */
+export type Eff<E, A> = {
+    readonly kind: 'pure';
+    readonly value: A;
+} | {
+    readonly kind: 'impure';
+    readonly effect: Operation;
+    readonly continuation: (value: never) => Eff<E, A>;
+};
+/**
+ * Handler de un efecto concreto. Recibe el input crudo y una
+ * continuación que, dado el resultado de la operación, produce el
+ * resto del cómputo. Devuelve un cómputo (posiblemente con otros
+ * efectos `R`) y resultado final `A`.
+ */
+export interface Handler<EName extends string, I, O, R, A> {
+    readonly effect: EName;
+    readonly handle: (input: I, continuation: (value: O) => Eff<R, A>) => Eff<R, A>;
+}
+/** Monoide para `runWriter`. */
+export interface Monoid<W> {
+    readonly empty: W;
+    readonly combine: (a: W, b: W) => W;
+}
+/** Resultado de `runException`. */
+export type ExceptionResult<E, A> = {
+    kind: 'ok';
+    value: A;
+} | {
+    kind: 'error';
+    error: E;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/type-theory/effects/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/types.ts"],"names":[],"mappings":"AAmBA,0EAA0E;AAC1E,MAAM,MAAM,MAAM,CAAC,IAAI,SAAS,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI;IACjD,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;IACnB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;CACtB,CAAC;AAEF,sDAAsD;AACtD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,mDAAmD;AACnD,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,IAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC5C;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpD,CAAC;AAEN;;;;;GAKG;AACH,MAAM,WAAW,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACvD,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACjF;AAED,gCAAgC;AAChC,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;CACrC;AAED,mCAAmC;AACnC,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC"}

package/dist/type-theory/effects/types.js

@@ -0,0 +1,21 @@
+"use strict";
+// ============================================================
+// Algebraic effects + free monads — Tipos núcleo
+// ============================================================
+//
+// Modelamos efectos algebraicos como un free monad explícito sobre
+// una firma de operaciones discriminadas por `tag`. La forma `Eff<E, A>`
+// es un árbol cuyas hojas son `pure` (valores) y cuyos nodos internos
+// son `impure` (operación + continuación). Un `handler` interpreta
+// una operación concreta y reduce el árbol.
+//
+// Convenciones:
+//   - `Effect<Name, In, Out>` es una *fila* de tipo a nivel de tipos:
+//     "este programa puede ejecutar la operación `Name` con input `In`
+//      esperando salida `Out`". El campo `output` es phantom.
+//   - El runtime sólo consume `tag` e `input`; el `output` vive en la
+//     posición de continuación (argumento de la k-función).
+//   - Mantenemos `unknown` en el runtime para no falsear unsoundness y
+//     usamos los tipos exclusivamente para guiar al consumidor.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/type-theory/effects/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/type-theory/effects/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iDAAiD;AACjD,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,yEAAyE;AACzE,sEAAsE;AACtE,mEAAmE;AACnE,4CAA4C;AAC5C,EAAE;AACF,gBAAgB;AAChB,sEAAsE;AACtE,uEAAuE;AACvE,8DAA8D;AAC9D,sEAAsE;AACtE,4DAA4D;AAC5D,uEAAuE;AACvE,gEAAgE"}

package/dist/type-theory/effects/writer.d.ts

@@ -0,0 +1,30 @@
+import type { Eff, Effect, Monoid } from './types';
+export declare const WRITER_TELL: "Writer.tell";
+export type WriterTell<W> = Effect<typeof WRITER_TELL, W, undefined>;
+export type Writer<W> = WriterTell<W>;
+/** Acumula un mensaje en el log. */
+export declare function tell<W>(w: W): Eff<WriterTell<W>, undefined>;
+/**
+ * Intérprete componible. Acumula los `tell` con el monoide y deja
+ * otros efectos intactos.
+ */
+export declare function handleWriter<R, W, A>(eff: Eff<unknown, A>, monoid: Monoid<W>): Eff<R, {
+    result: A;
+    log: W;
+}>;
+/**
+ * Intérprete terminal: ejecuta combinando todos los `tell` con el
+ * monoide dado. Devuelve `{ result, log }`. Lanza si encuentra otra
+ * operación sin manejar.
+ */
+export declare function runWriter<W, A>(eff: Eff<unknown, A>, monoid: Monoid<W>): {
+    result: A;
+    log: W;
+};
+/** Monoide concatenación de listas. */
+export declare function listMonoid<W>(): Monoid<W[]>;
+/** Monoide concatenación de strings. */
+export declare const stringMonoid: Monoid<string>;
+/** Monoide aditivo sobre números. */
+export declare const sumMonoid: Monoid<number>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/type-theory/effects/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/writer.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEnD,eAAO,MAAM,WAAW,EAAG,aAAsB,CAAC;AAElD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,WAAW,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;AACrE,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAEtC,oCAAoC;AACpC,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAE3D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAClC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EACpB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,GAAG,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,CAAA;CAAE,CAAC,CAe/B;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,CAAA;CAAE,CAa9F;AAID,uCAAuC;AACvC,wBAAgB,UAAU,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAK3C;AAED,wCAAwC;AACxC,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAGvC,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,CAGpC,CAAC"}