@metta-ts/edsl 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MesTTo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @metta-ts/edsl
+
+A typed TypeScript eDSL for [MeTTa TS](https://github.com/MesTTo/Meta-TypeScript-Talk). Write MeTTa with typed term builders and special-form combinators, or a tagged-template surface, and run it on the real interpreter. Any TypeScript value drops in as a grounded atom automatically.
+
+It is a thin layer over [`@metta-ts/hyperon`](https://github.com/MesTTo/Meta-TypeScript-Talk/tree/main/packages/hyperon): every builder produces an ordinary atom that runs on the existing engine, so you get MeTTa's full semantics: rewrite rules, nondeterminism, pattern matching, and types.
+
+## Install
+
+```bash
+npm install @metta-ts/edsl
+```
+
+## Usage
+
+```ts
+import { mettaDB, S, v, rel, iff, gt, lt, mul, sub, m, ValueAtom, type GroundedAtom } from "@metta-ts/edsl";
+
+const db = mettaDB();
+
+// Facts + a typed match query (rows are typed by the variables).
+db.add(rel("Likes")(S.Ada, S.Coffee), rel("Likes")(S.Ada, S.Chocolate));
+const thing = v<string>("thing");
+db.query(rel("Likes")(S.Ada, thing), { thing }); // [{ thing: "Coffee" }, { thing: "Chocolate" }]
+
+// Rewrite rules + grounded arithmetic, recursion, nondeterminism.
+const x = v<number>("x");
+db.rule(rel("fact")(x), iff(gt(x, 0), mul(x, rel("fact")(sub(x, 1))), 1));
+db.evalJs(rel("fact")(5)); // [120]
+
+// Pass a TypeScript object straight in (auto-grounded), operated on by a TS function.
+db.op("balance-of", (args) => [ValueAtom((args[0] as GroundedAtom).jsValue<{ balance: number }>().balance)]);
+const account = { owner: "Tom", balance: 100 };
+db.evalJs(rel("balance-of")(account)); // [100]
+db.evalJs(m`(balance-of ${account})`); // [100], same, via the template
+
+// Async grounded ops, awaited.
+db.asyncOp("fetch", async () => [ValueAtom(await getTemp())]);
+await db.evalJsAsync(rel("fetch")());
+```
+
+## The two surfaces
+
+- Typed builders construct terms with static types: `S`/`v`/`e`/`rel`, `rule`/`decl`/`arrow`, the special forms `iff`/`caseOf`/`lett`/`letStar`/`matchSelf`/`superpose`/`collapse`/`empty`/`unify`, the grounded ops `add`/`sub`/`mul`/`div`/`mod`, `eq`/`gt`/`lt`/`ge`/`le`, `and`/`or`/`not`, `carAtom`/`cdrAtom`/`consAtom`, and `list`/`nil`. Builders compose, so nested patterns and repeated variables are just nested calls.
+- The tagged template `m\`...\`` (and `mAll` for several atoms) runs the real parser, so it expresses every MeTTa form, and `${value}` auto-grounds (the easiest way to drop a TS object in).
+
+## The runner
+
+`mettaDB()` keeps MeTTa's two query mechanisms distinct: `query(pattern, vars)` does `match &self` over stored atoms and returns typed binding rows; `eval(atom)` (and `evalJs`, `evalAsync`, `evalJsAsync`) rewrites with the `=` rules and returns the nondeterministic results. `op`/`asyncOp` register TypeScript functions as grounded operations. `ground(x)` is the primitive behind auto-grounding.
+
+## License
+
+[MIT](https://github.com/MesTTo/Meta-TypeScript-Talk/blob/main/LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+import { Atom, VariableAtom, SymbolAtom, ExpressionAtom, MeTTa } from '@metta-ts/hyperon';
+export { Atom, GroundedAtom, ValueAtom, atomToJs } from '@metta-ts/hyperon';
+
+/** A typed variable. The phantom `T` is the JS type its binding unwraps to in a query result; it is a
+ *  compile-time promise, while the runtime value is whatever unifies. */
+type Var<T = unknown> = VariableAtom & {
+    readonly __varType?: T;
+};
+/** Anything a builder accepts in term position: an atom (incl. a {@link Var}), or a JS value to ground. */
+type Term = Atom | number | string | boolean | bigint | object | null | undefined;
+/** Extract a {@link Var}'s phantom type (defaults to `unknown`). */
+type VarValue<X> = X extends Var<infer T> ? T : unknown;
+/** A fresh typed variable: `v("x")` or `v<number>("n")`. */
+declare const v: <T = unknown>(name: string) => Var<T>;
+/** `S` builds a symbol two ways: as a function `S("foo")` or as a property `S.foo`. */
+type SymbolBuilder = ((name: string) => SymbolAtom) & {
+    readonly [key: string]: SymbolAtom;
+};
+declare const S: SymbolBuilder;
+/** Coerce a {@link Term} to an atom: atoms and variables pass through; every other JS value is grounded. */
+declare function ground(x: Term): Atom;
+/** A raw expression (tuple) from its items, each auto-grounded: `e(x, y, x)` builds `($x $y $x)`. Use it
+ *  for patterns that are not headed by a functor, e.g. repeated-variable patterns or pair structures. */
+declare const e: (...items: Term[]) => ExpressionAtom;
+/** A functor builder: `rel("parent")` returns `(a, b) => (parent a b)`, auto-grounding each argument.
+ *  Builders compose, so nested patterns like `rel("swap")(rel("Pair")(x, y))` are just function calls. */
+declare function rel(name: string): (...args: Term[]) => ExpressionAtom;
+/** The empty expression `()`, MeTTa's conventional empty/nil list. */
+declare const nil: () => ExpressionAtom;
+/** A Lisp-style cons list: `list([a, b, c])` builds `(:: a (:: b (:: c ())))`. Override the constructor
+ *  and terminator symbols if your code uses different ones. */
+declare function list(items: Term[], opts?: {
+    cons?: string;
+    nil?: Atom;
+}): Atom;
+
+/** A rewrite rule `(= head body)`. Define several with the same head for nondeterministic results. */
+declare const rule: (head: Term, body: Term) => ExpressionAtom;
+/** A type declaration `(: subject type)`. */
+declare const decl: (subject: Term, type: Term) => ExpressionAtom;
+/** A function type `(-> A B ... R)`. */
+declare const arrow: (...types: Term[]) => ExpressionAtom;
+/** `(if cond then else)`. Only the taken branch is evaluated. */
+declare const iff: (cond: Term, then: Term, els: Term) => ExpressionAtom;
+/** `(case scrutinee ((pat body) ...))`, sequential mutually-exclusive pattern matching. */
+declare const caseOf: (scrutinee: Term, cases: ReadonlyArray<readonly [Term, Term]>) => ExpressionAtom;
+/** `(let pattern value body)`: unify `value` against `pattern`, then evaluate `body`. */
+declare const lett: (pattern: Term, value: Term, body: Term) => ExpressionAtom;
+/** `(let* ((pat val) ...) body)`: sequential lets. */
+declare const letStar: (bindings: ReadonlyArray<readonly [Term, Term]>, body: Term) => ExpressionAtom;
+/** `(match space pattern template)`. Defaults to `&self`, the program's own space. */
+declare const matchSelf: (pattern: Term, template: Term, space?: Term) => ExpressionAtom;
+/** `(superpose (a b ...))`: a nondeterministic choice among the items. */
+declare const superpose: (...items: Term[]) => ExpressionAtom;
+/** `(collapse x)`: gather all nondeterministic results of `x` into a single expression. */
+declare const collapse: (x: Term) => ExpressionAtom;
+/** `(empty)`: no results, which prunes a branch. */
+declare const empty: () => ExpressionAtom;
+/** `(unify a b then else)`: low-level unification with then/else continuations. */
+declare const unify: (a: Term, b: Term, then: Term, els: Term) => ExpressionAtom;
+/** Arithmetic grounded operations. */
+declare const add: (a: Term, b: Term) => ExpressionAtom;
+declare const sub: (a: Term, b: Term) => ExpressionAtom;
+declare const mul: (a: Term, b: Term) => ExpressionAtom;
+declare const div: (a: Term, b: Term) => ExpressionAtom;
+declare const mod: (a: Term, b: Term) => ExpressionAtom;
+/** Comparison grounded operations (return `True`/`False`). */
+declare const eq: (a: Term, b: Term) => ExpressionAtom;
+declare const gt: (a: Term, b: Term) => ExpressionAtom;
+declare const lt: (a: Term, b: Term) => ExpressionAtom;
+declare const ge: (a: Term, b: Term) => ExpressionAtom;
+declare const le: (a: Term, b: Term) => ExpressionAtom;
+/** Boolean grounded operations. */
+declare const and: (a: Term, b: Term) => ExpressionAtom;
+declare const or: (a: Term, b: Term) => ExpressionAtom;
+declare const not: (x: Term) => ExpressionAtom;
+/** Expression/list grounded operations. */
+declare const carAtom: (x: Term) => ExpressionAtom;
+declare const cdrAtom: (x: Term) => ExpressionAtom;
+declare const consAtom: (head: Term, tail: Term) => ExpressionAtom;
+/** `(decons-atom expr)`: split a non-empty expression into `(head tail)`. */
+declare const deconsAtom: (x: Term) => ExpressionAtom;
+/** `(quote x)`: hold `x` as data so the interpreter does not evaluate it. */
+declare const quote: (x: Term) => ExpressionAtom;
+/** Type introspection. `getType` reports an atom's declared/inferred type; `getMetatype` reports its
+ *  meta-type (`Symbol`/`Variable`/`Expression`/`Grounded`). */
+declare const getType: (x: Term) => ExpressionAtom;
+declare const getMetatype: (x: Term) => ExpressionAtom;
+/** Assertions for eDSL tests. Each returns the unit atom `()` on success and an
+ *  `(Error ...)` atom on failure, matching Hyperon's stdlib. `assertEqual` compares evaluated results;
+ *  `assertAlphaEqual` compares up to a consistent renaming of variables. */
+declare const assertEqual: (a: Term, b: Term) => ExpressionAtom;
+declare const assertAlphaEqual: (a: Term, b: Term) => ExpressionAtom;
+/** Set operations over the (collapsed) results of their arguments, deduplicating modulo equality.
+ *  `unique` removes duplicates from one result set; `union`/`intersection`/`subtraction` combine two. */
+declare const unique: (x: Term) => ExpressionAtom;
+declare const union: (a: Term, b: Term) => ExpressionAtom;
+declare const intersection: (a: Term, b: Term) => ExpressionAtom;
+declare const subtraction: (a: Term, b: Term) => ExpressionAtom;
+/** `(println! x)`: print `x` (a side effect); returns the unit atom `()`. */
+declare const println: (x: Term) => ExpressionAtom;
+/** `(sealed (vars...) body)`: alpha-rename `body`'s variables (except `vars`) to fresh names, so a
+ *  template can be reused without variable capture. */
+declare const sealed: (vars: ReadonlyArray<Term>, body: Term) => ExpressionAtom;
+
+/** Parse a MeTTa template into the atoms it contains, with `${...}` holes auto-grounded. */
+declare function mAll(strings: TemplateStringsArray, ...values: Term[]): Atom[];
+/** Parse a MeTTa template into one top-level atom. Throws otherwise; use {@link mAll} for several. */
+declare function m(strings: TemplateStringsArray, ...values: Term[]): Atom;
+
+/** One typed binding row from a {@link MettaDB.query}: each requested variable mapped to its JS value. */
+type Row<V extends Record<string, Var>> = {
+    [K in keyof V]: VarValue<V[K]>;
+};
+/** A typed MeTTa runner. Build it with {@link mettaDB}. */
+declare class MettaDB {
+    /** The underlying hyperon runner, for anything the eDSL does not wrap. */
+    readonly metta: MeTTa;
+    /** Add atoms (facts, rules, type declarations) to the program space. JS values are auto-grounded. */
+    add(...atoms: Term[]): this;
+    /** Add a rewrite rule `(= head body)`. Call repeatedly with the same head for nondeterminism. */
+    rule(head: Term, body: Term): this;
+    /** Add a type declaration `(: subject type)`. */
+    declare(subject: Term, type: Term): this;
+    /** Evaluate an atom by rewriting, returning all (nondeterministic) result atoms. */
+    eval(atom: Term): Atom[];
+    /** Evaluate and return the first result atom, or `undefined` for no result. */
+    evalFirst(atom: Term): Atom | undefined;
+    /** Like {@link eval}, but each result unwrapped to a plain JS value (grounded -> value, symbol -> name,
+     *  expression -> array). */
+    evalJs(atom: Term): unknown[];
+    /** Evaluate `(assertEqual actual expected)` and report whether it passed. A passing assert reduces to
+     *  the unit atom `()`; a failing one to an `(Error ...)`. Use it for tests written in the eDSL. */
+    test(actual: Term, expected: Term): boolean;
+    /** Like {@link eval}, awaiting any async grounded operations reached during evaluation. */
+    evalAsync(atom: Term): Promise<Atom[]>;
+    /** Like {@link evalJs}, awaiting async grounded operations. */
+    evalJsAsync(atom: Term): Promise<unknown[]>;
+    /** `match &self pattern` over stored atoms, returning one typed row of JS bindings per match. */
+    query<V extends Record<string, Var>>(pattern: Term, vars: V): Array<Row<V>>;
+    /** Register a synchronous TypeScript function as a grounded operation callable from MeTTa. */
+    op(name: string, fn: (args: Atom[]) => Atom[]): this;
+    /** Register an async TypeScript function (I/O) as a grounded operation; await it via {@link evalAsync}. */
+    asyncOp(name: string, fn: (args: Atom[]) => Promise<Atom[]>): this;
+    /** Run raw MeTTa source, one result group per `!`-query. */
+    run(src: string): Atom[][];
+}
+/** Create an ergonomic, typed MeTTa runner. */
+declare const mettaDB: () => MettaDB;
+
+export { MettaDB, type Row, S, type SymbolBuilder, type Term, type Var, type VarValue, add, and, arrow, assertAlphaEqual, assertEqual, carAtom, caseOf, cdrAtom, collapse, consAtom, decl, deconsAtom, div, e, empty, eq, ge, getMetatype, getType, ground, gt, iff, intersection, le, letStar, lett, list, lt, m, mAll, matchSelf, mettaDB, mod, mul, nil, not, or, println, quote, rel, rule, sealed, sub, subtraction, superpose, unify, union, unique, v };

package/dist/index.js

@@ -0,0 +1,247 @@
+// src/term.ts
+import {
+  Atom,
+  S as hS,
+  V,
+  E,
+  ValueAtom
+} from "@metta-ts/hyperon";
+var v = (name) => V(name);
+var S = new Proxy(((name) => hS(name)), {
+  get(_target, prop) {
+    return typeof prop === "string" ? hS(prop) : void 0;
+  }
+});
+function ground(x) {
+  if (x instanceof Atom) return x;
+  return ValueAtom(x);
+}
+var e = (...items) => E(...items.map(ground));
+function rel(name) {
+  const head = hS(name);
+  return (...args) => E(head, ...args.map(ground));
+}
+var nil = () => E();
+function list(items, opts) {
+  const cons = hS(opts?.cons ?? "::");
+  let acc = opts?.nil ?? E();
+  for (let i = items.length - 1; i >= 0; i--) acc = E(cons, ground(items[i]), acc);
+  return acc;
+}
+
+// src/forms.ts
+import { E as E2, S as S2 } from "@metta-ts/hyperon";
+var rule = (head, body) => E2(S2("="), ground(head), ground(body));
+var decl = (subject, type) => E2(S2(":"), ground(subject), ground(type));
+var arrow = (...types) => E2(S2("->"), ...types.map(ground));
+var iff = (cond, then, els) => E2(S2("if"), ground(cond), ground(then), ground(els));
+var caseOf = (scrutinee, cases) => E2(S2("case"), ground(scrutinee), E2(...cases.map(([pat, body]) => E2(ground(pat), ground(body)))));
+var lett = (pattern, value, body) => E2(S2("let"), ground(pattern), ground(value), ground(body));
+var letStar = (bindings, body) => E2(S2("let*"), E2(...bindings.map(([pat, val]) => E2(ground(pat), ground(val)))), ground(body));
+var matchSelf = (pattern, template, space = S2("&self")) => E2(S2("match"), ground(space), ground(pattern), ground(template));
+var superpose = (...items) => E2(S2("superpose"), E2(...items.map(ground)));
+var collapse = (x) => E2(S2("collapse"), ground(x));
+var empty = () => E2(S2("empty"));
+var unify = (a, b, then, els) => E2(S2("unify"), ground(a), ground(b), ground(then), ground(els));
+var op2 = (name) => (a, b) => E2(S2(name), ground(a), ground(b));
+var add = op2("+");
+var sub = op2("-");
+var mul = op2("*");
+var div = op2("/");
+var mod = op2("%");
+var eq = op2("==");
+var gt = op2(">");
+var lt = op2("<");
+var ge = op2(">=");
+var le = op2("<=");
+var op1 = (name) => (x) => E2(S2(name), ground(x));
+var and = op2("and");
+var or = op2("or");
+var not = op1("not");
+var carAtom = op1("car-atom");
+var cdrAtom = op1("cdr-atom");
+var consAtom = (head, tail) => E2(S2("cons-atom"), ground(head), ground(tail));
+var deconsAtom = op1("decons-atom");
+var quote = op1("quote");
+var getType = op1("get-type");
+var getMetatype = op1("get-metatype");
+var assertEqual = op2("assertEqual");
+var assertAlphaEqual = op2("assertAlphaEqual");
+var unique = op1("unique");
+var union = op2("union");
+var intersection = op2("intersection");
+var subtraction = op2("subtraction");
+var println = op1("println!");
+var sealed = (vars, body) => E2(S2("sealed"), E2(...vars.map(ground)), ground(body));
+
+// src/template.ts
+import {
+  SExprParser,
+  SymbolAtom,
+  ExpressionAtom,
+  E as E3,
+  standardTokenizer
+} from "@metta-ts/hyperon";
+var SLOT = (i) => `__metta_ts_slot_${i}__`;
+var SLOT_RE = /^__metta_ts_slot_(\d+)__$/;
+var sharedTokenizer;
+var tokenizer = () => sharedTokenizer ??= standardTokenizer();
+function substituteSlots(atom, slots) {
+  if (atom instanceof SymbolAtom) {
+    const match = SLOT_RE.exec(atom.name());
+    return match ? slots[Number(match[1])] : atom;
+  }
+  if (atom instanceof ExpressionAtom)
+    return E3(...atom.children().map((c) => substituteSlots(c, slots)));
+  return atom;
+}
+function mAll(strings, ...values) {
+  let src = strings[0];
+  for (let i = 0; i < values.length; i++) src += SLOT(i) + strings[i + 1];
+  const slots = values.map(ground);
+  return new SExprParser(src).parseAll(tokenizer()).map((a) => substituteSlots(a, slots));
+}
+function m(strings, ...values) {
+  const atoms = mAll(strings, ...values);
+  if (atoms.length !== 1)
+    throw new Error(
+      `m\`...\`: expected exactly one atom, got ${atoms.length}. Use mAll\`...\` for several.`
+    );
+  return atoms[0];
+}
+
+// src/db.ts
+import { MeTTa, atomToJs } from "@metta-ts/hyperon";
+var MettaDB = class {
+  /** The underlying hyperon runner, for anything the eDSL does not wrap. */
+  metta = new MeTTa();
+  /** Add atoms (facts, rules, type declarations) to the program space. JS values are auto-grounded. */
+  add(...atoms) {
+    const space = this.metta.space();
+    for (const a of atoms) space.addAtom(ground(a));
+    return this;
+  }
+  /** Add a rewrite rule `(= head body)`. Call repeatedly with the same head for nondeterminism. */
+  rule(head, body) {
+    return this.add(rule(head, body));
+  }
+  /** Add a type declaration `(: subject type)`. */
+  declare(subject, type) {
+    return this.add(decl(subject, type));
+  }
+  /** Evaluate an atom by rewriting, returning all (nondeterministic) result atoms. */
+  eval(atom) {
+    return this.metta.evaluateAtom(ground(atom));
+  }
+  /** Evaluate and return the first result atom, or `undefined` for no result. */
+  evalFirst(atom) {
+    return this.eval(atom)[0];
+  }
+  /** Like {@link eval}, but each result unwrapped to a plain JS value (grounded -> value, symbol -> name,
+   *  expression -> array). */
+  evalJs(atom) {
+    return this.eval(atom).map(atomToJs);
+  }
+  /** Evaluate `(assertEqual actual expected)` and report whether it passed. A passing assert reduces to
+   *  the unit atom `()`; a failing one to an `(Error ...)`. Use it for tests written in the eDSL. */
+  test(actual, expected) {
+    const results = this.eval(assertEqual(actual, expected));
+    if (results.length !== 1) return false;
+    const js = atomToJs(results[0]);
+    return Array.isArray(js) && js.length === 0;
+  }
+  /** Like {@link eval}, awaiting any async grounded operations reached during evaluation. */
+  async evalAsync(atom) {
+    return this.metta.evaluateAtomAsync(ground(atom));
+  }
+  /** Like {@link evalJs}, awaiting async grounded operations. */
+  async evalJsAsync(atom) {
+    return (await this.evalAsync(atom)).map(atomToJs);
+  }
+  /** `match &self pattern` over stored atoms, returning one typed row of JS bindings per match. */
+  query(pattern, vars) {
+    const set = this.metta.space().query(ground(pattern));
+    return set.frames.map((frame) => {
+      const row = {};
+      for (const key in vars) {
+        const bound = frame.resolve(vars[key]);
+        row[key] = bound === void 0 ? void 0 : atomToJs(bound);
+      }
+      return row;
+    });
+  }
+  /** Register a synchronous TypeScript function as a grounded operation callable from MeTTa. */
+  op(name, fn) {
+    this.metta.registerOperation(name, fn);
+    return this;
+  }
+  /** Register an async TypeScript function (I/O) as a grounded operation; await it via {@link evalAsync}. */
+  asyncOp(name, fn) {
+    this.metta.registerAsyncOperation(name, fn);
+    return this;
+  }
+  /** Run raw MeTTa source, one result group per `!`-query. */
+  run(src) {
+    return this.metta.run(src);
+  }
+};
+var mettaDB = () => new MettaDB();
+
+// src/index.ts
+import { Atom as Atom3, ValueAtom as ValueAtom2, atomToJs as atomToJs2 } from "@metta-ts/hyperon";
+export {
+  Atom3 as Atom,
+  MettaDB,
+  S,
+  ValueAtom2 as ValueAtom,
+  add,
+  and,
+  arrow,
+  assertAlphaEqual,
+  assertEqual,
+  atomToJs2 as atomToJs,
+  carAtom,
+  caseOf,
+  cdrAtom,
+  collapse,
+  consAtom,
+  decl,
+  deconsAtom,
+  div,
+  e,
+  empty,
+  eq,
+  ge,
+  getMetatype,
+  getType,
+  ground,
+  gt,
+  iff,
+  intersection,
+  le,
+  letStar,
+  lett,
+  list,
+  lt,
+  m,
+  mAll,
+  matchSelf,
+  mettaDB,
+  mod,
+  mul,
+  nil,
+  not,
+  or,
+  println,
+  quote,
+  rel,
+  rule,
+  sealed,
+  sub,
+  subtraction,
+  superpose,
+  unify,
+  union,
+  unique,
+  v
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@metta-ts/edsl",
+  "version": "1.0.0",
+  "author": "MesTTo",
+  "license": "MIT",
+  "description": "Ergonomic, typed TypeScript eDSL for MeTTa: typed term builders, rewrite rules, a tagged-template surface, and auto-grounding of TypeScript values.",
+  "keywords": [
+    "metta",
+    "hyperon",
+    "edsl",
+    "dsl",
+    "term-rewriting",
+    "typescript"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@metta-ts/hyperon": "1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MesTTo/Meta-TypeScript-Talk.git",
+    "directory": "packages/edsl"
+  },
+  "homepage": "https://github.com/MesTTo/Meta-TypeScript-Talk#readme",
+  "bugs": {
+    "url": "https://github.com/MesTTo/Meta-TypeScript-Talk/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  }
+}