@metta-ts/das-gateway 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,30 @@
+# @metta-ts/das-gateway
+
+A transport-agnostic gateway that bridges [MeTTa TS](https://github.com/MesTTo/Meta-TypeScript-Talk) to a SingularityNET Distributed AtomSpace (DAS). It encodes a pattern query, sends it over an injected transport (Connect/HTTP, usable from the browser), and decodes the bindings back into MeTTa atoms.
+
+## Install
+
+```bash
+npm install @metta-ts/das-gateway
+```
+
+## Usage
+
+```ts
+import { queryDas, type GatewayTransport } from "@metta-ts/das-gateway";
+import { parse, standardTokenizer } from "@metta-ts/core";
+
+// You provide the transport (e.g. a Connect client). The gateway is browser-reachable over HTTP.
+const transport: GatewayTransport = {
+  /* query(request) => Promise<QueryResponse> */
+};
+
+const pattern = parse("(Parent $x Bob)", standardTokenizer())!;
+const bindings = await queryDas(transport, "&self", pattern);
+```
+
+Querying a DAS involves network I/O, so the gateway's query API is async. Pair it with the async evaluation path in `@metta-ts/core` to call it from MeTTa source.
+
+## License
+
+[MIT](https://github.com/MesTTo/Meta-TypeScript-Talk/blob/main/LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { Bindings, Atom } from '@metta-ts/core';
+
+/** Gateway query payloads use MeTTa source strings on the wire. */
+interface QueryRequest {
+    readonly space: string;
+    readonly pattern: string;
+}
+interface QueryResponse {
+    /** Each solution as a flat list of `[varName, atomSource]` pairs. */
+    readonly bindings: ReadonlyArray<ReadonlyArray<readonly [string, string]>>;
+}
+/** Shared MeTTa source wire-codec helpers for gateway clients and servers. */
+declare const encodePattern: (a: Atom) => string;
+declare const decodeBindings: (resp: QueryResponse) => Bindings[];
+/** Async browser-to-gateway transport, for example a Connect-web client. */
+interface GatewayTransport {
+    query(req: QueryRequest): Promise<QueryResponse>;
+}
+/** Browser-side async DAS access. Limitation: kernel `match` is synchronous while gateway transport
+ *  is async, so call this directly instead of `(match &das ...)`. */
+declare function queryDas(transport: GatewayTransport, space: string, pattern: Atom): Promise<Bindings[]>;
+
+export { type GatewayTransport, type QueryRequest, type QueryResponse, decodeBindings, encodePattern, queryDas };

package/dist/index.js

@@ -0,0 +1,17 @@
+// src/index.ts
+import { format, parse, standardTokenizer } from "@metta-ts/core";
+var encodePattern = (a) => format(a);
+var decodeBindings = (resp) => {
+  const tk = standardTokenizer();
+  return resp.bindings.map(
+    (sol) => sol.map(([x, src]) => ({ tag: "val", x, a: parse(src, tk), y: void 0 }))
+  );
+};
+async function queryDas(transport, space, pattern) {
+  return decodeBindings(await transport.query({ space, pattern: encodePattern(pattern) }));
+}
+export {
+  decodeBindings,
+  encodePattern,
+  queryDas
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@metta-ts/das-gateway",
+  "version": "1.0.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@metta-ts/core": "1.0.0"
+  },
+  "author": "MesTTo",
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "HTTP/Connect gateway bridging MeTTa TS to a Distributed AtomSpace, reachable from the browser.",
+  "keywords": [
+    "metta",
+    "hyperon",
+    "das",
+    "gateway",
+    "singularitynet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MesTTo/Meta-TypeScript-Talk.git",
+    "directory": "packages/das-gateway"
+  },
+  "homepage": "https://github.com/MesTTo/Meta-TypeScript-Talk#readme",
+  "bugs": {
+    "url": "https://github.com/MesTTo/Meta-TypeScript-Talk/issues"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  }
+}