@ariestools/aries-chain-serve 0.1.14

package/README.md

@@ -0,0 +1,25 @@
+# @ariestools/aries-chain-serve
+
+> **Dev only.** This package is a local development fixture — it accepts any
+> S3 credentials, carries no auth or metrics, and only ships an ephemeral
+> in-memory backing. It is not meant for production at this time; production
+> chains are published to real object storage (S3/R2) behind the standard
+> sub-domain layout.
+
+Serves an XL1/XYO published-chain layout from a single origin using
+subfolders (`/blocks`, `/state`, `/indexes`) instead of the production
+sub-domains. The subfolders are S3 buckets on an embedded S3-compatible
+server ([s3rver](https://www.npmjs.com/package/s3rver)), so the existing
+`ariesi xyo s3 ...` publish commands write into it unchanged while readers
+(`RestBlockViewer`, `curl`) fetch the same layout paths over plain HTTP.
+The server also accepts an explicit TLS certificate and key. The `aries chain
+up --ssl auto` command configures those inputs with a locally trusted macOS
+development certificate and advertises `https://chain.aries.test:8791`.
+
+Backings (`CHAIN_BACKING`): `memory` (ephemeral temp directory, wiped on
+shutdown). `disk` and `s3` are planned.
+
+The daemon bin (`dist/bin/chainServer.mjs`) is spawned by `aries chain up`;
+env config: `CHAIN_PORT` (default 8791), `HOST` (default 127.0.0.1),
+`CHAIN_BACKING` (default `memory`), `CHAIN_PUBLIC_HOST`, `CHAIN_TLS_CERT`, and
+`CHAIN_TLS_KEY`.

package/dist/bin/chainServer.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import S3rver from "s3rver";
+//#region src/ChainBacking.ts
+const CHAIN_BACKINGS = ["memory"];
+function isChainBackingKind(value) {
+	return CHAIN_BACKINGS.includes(value);
+}
+function createMemoryBacking() {
+	let dir;
+	return {
+		description: "memory (ephemeral temp directory)",
+		get directory() {
+			if (dir === void 0) throw new Error("Memory backing not prepared");
+			return dir;
+		},
+		async prepare() {
+			dir ??= await mkdtemp(path.join(tmpdir(), "aries-chain-"));
+		},
+		async cleanup() {
+			if (dir !== void 0) await rm(dir, {
+				recursive: true,
+				force: true
+			});
+			dir = void 0;
+		}
+	};
+}
+function resolveBacking(kind) {
+	switch (kind) {
+		case "memory": return createMemoryBacking();
+	}
+}
+//#endregion
+//#region src/startChainServer.ts
+/**
+* The bucket-per-role split of the published chain layout. Path-style
+* addressing turns each bucket into a subfolder of the one origin —
+* `/blocks`, `/state`, `/indexes` — replacing the production sub-domains.
+*/
+const CHAIN_BUCKETS = [
+	"blocks",
+	"state",
+	"indexes"
+];
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 8791;
+/** Allow browser RestBlockViewer clients to read the layout cross-origin. */
+const CORS_ALLOW_READS = `<CORSConfiguration>
+  <CORSRule>
+    <AllowedOrigin>*</AllowedOrigin>
+    <AllowedMethod>GET</AllowedMethod>
+    <AllowedMethod>HEAD</AllowedMethod>
+    <AllowedHeader>*</AllowedHeader>
+  </CORSRule>
+</CORSConfiguration>`;
+/**
+* Boots an S3-compatible server (s3rver) pre-configured with the three chain
+* layout buckets. Writers use the S3 API (any credentials are accepted);
+* readers fetch `/{bucket}/{layout-path}` over HTTP or optional TLS.
+*
+* DEV ONLY — this server is a local development fixture, not a production
+* chain host. It intentionally skips the production concerns the datalake
+* and signing-pool planes carry (auth, metrics, durable multi-instance
+* storage): any S3 credentials are accepted and the only backing is an
+* ephemeral temp directory. Production chains stay on the real sub-domain
+* layout (blocks/state/indexes origins backed by S3/R2).
+*/
+async function startChainServer(options) {
+	const host = options.host ?? DEFAULT_HOST;
+	const publicHost = options.publicHost ?? host;
+	await options.backing.prepare();
+	const server = new S3rver({
+		address: host,
+		allowMismatchedSignatures: true,
+		cert: options.tls?.cert,
+		configureBuckets: CHAIN_BUCKETS.map((name) => ({
+			name,
+			configs: [CORS_ALLOW_READS]
+		})),
+		directory: options.backing.directory,
+		key: options.tls?.key,
+		port: options.port ?? DEFAULT_PORT,
+		silent: options.silent ?? false,
+		vhostBuckets: false
+	});
+	try {
+		const { port } = await server.run();
+		return {
+			baseUrl: `${options.tls === void 0 ? "http" : "https"}://${publicHost}:${port}`,
+			port,
+			close: async () => {
+				await server.close();
+				await options.backing.cleanup();
+			}
+		};
+	} catch (error) {
+		await options.backing.cleanup();
+		throw error;
+	}
+}
+//#endregion
+//#region src/bin/chainServer.ts
+/**
+* Chain REST server daemon: serves an XL1/XYO published-chain layout from a
+* single origin using subfolders (/blocks, /state, /indexes) instead of the
+* production sub-domains. The subfolders are S3 buckets on an embedded
+* S3-compatible server, so the existing `xyo s3 ...` publish commands write
+* into it unchanged while readers (RestBlockViewer, curl) fetch the same
+* layout paths over HTTP or optional TLS.
+*/
+const PORT = Number(process.env.CHAIN_PORT ?? 8791);
+const HOST = process.env.HOST ?? "127.0.0.1";
+const BACKING = process.env.CHAIN_BACKING ?? "memory";
+const PUBLIC_HOST = process.env.CHAIN_PUBLIC_HOST;
+const TLS_CERT_PATH = process.env.CHAIN_TLS_CERT;
+const TLS_KEY_PATH = process.env.CHAIN_TLS_KEY;
+async function main() {
+	if (!isChainBackingKind(BACKING)) throw new Error(`Unsupported CHAIN_BACKING '${BACKING}' (supported: ${CHAIN_BACKINGS.join(", ")})`);
+	const backing = resolveBacking(BACKING);
+	if (TLS_CERT_PATH === void 0 !== (TLS_KEY_PATH === void 0)) throw new Error("CHAIN_TLS_CERT and CHAIN_TLS_KEY must be provided together");
+	const server = await startChainServer({
+		backing,
+		host: HOST,
+		port: PORT,
+		publicHost: PUBLIC_HOST,
+		tls: TLS_CERT_PATH === void 0 || TLS_KEY_PATH === void 0 ? void 0 : {
+			cert: readFileSync(TLS_CERT_PATH),
+			key: readFileSync(TLS_KEY_PATH)
+		}
+	});
+	console.log(`chain server listening at ${server.baseUrl}\n` + CHAIN_BUCKETS.map((bucket) => `  /${bucket.padEnd(7)} ${server.baseUrl}/${bucket}`).join("\n") + `\nbacking: ${backing.description} — ${backing.directory}`);
+	const shutdown = async () => {
+		await server.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", () => {
+		shutdown();
+	});
+	process.on("SIGTERM", () => {
+		shutdown();
+	});
+}
+main().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/node/ChainBacking.d.ts

@@ -0,0 +1,21 @@
+export declare const CHAIN_BACKINGS: readonly ["memory"];
+export type ChainBackingKind = typeof CHAIN_BACKINGS[number];
+export declare function isChainBackingKind(value: string): value is ChainBackingKind;
+/**
+ * Where the served chain layout's objects live. v1 ships only `memory` (an
+ * ephemeral temp directory wiped on shutdown); a `disk` kind (caller-owned
+ * directory, no-op cleanup) is the natural next addition. An `s3` kind will
+ * proxy a remote bucket instead of running a local store, so it will lift
+ * this seam up to the server level rather than fit this interface.
+ */
+export interface ChainBacking {
+    /** Human-readable label for banners and status output. */
+    readonly description: string;
+    /** Directory the S3-compatible server persists bucket objects under. Only valid after prepare(). */
+    readonly directory: string;
+    cleanup(): Promise<void>;
+    prepare(): Promise<void>;
+}
+export declare function createMemoryBacking(): ChainBacking;
+export declare function resolveBacking(kind: ChainBackingKind): ChainBacking;
+//# sourceMappingURL=ChainBacking.d.ts.map

package/dist/node/ChainBacking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainBacking.d.ts","sourceRoot":"","sources":["../../src/ChainBacking.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,qBAAsB,CAAA;AACjD,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAA;AAE5D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,gBAAgB,CAE3E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED,wBAAgB,mBAAmB,IAAI,YAAY,CAgBlD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAMnE"}

package/dist/node/bin/chainServer.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Chain REST server daemon: serves an XL1/XYO published-chain layout from a
+ * single origin using subfolders (/blocks, /state, /indexes) instead of the
+ * production sub-domains. The subfolders are S3 buckets on an embedded
+ * S3-compatible server, so the existing `xyo s3 ...` publish commands write
+ * into it unchanged while readers (RestBlockViewer, curl) fetch the same
+ * layout paths over HTTP or optional TLS.
+ */
+export {};
+//# sourceMappingURL=chainServer.d.ts.map

package/dist/node/bin/chainServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainServer.d.ts","sourceRoot":"","sources":["../../../src/bin/chainServer.ts"],"names":[],"mappings":";AAEA;;;;;;;GAOG"}

package/dist/node/index.d.ts

@@ -0,0 +1,5 @@
+export type { ChainBacking, ChainBackingKind } from './ChainBacking.ts';
+export { CHAIN_BACKINGS, createMemoryBacking, isChainBackingKind, resolveBacking, } from './ChainBacking.ts';
+export type { ChainBucket, ChainServerOptions, RunningChainServer, } from './startChainServer.ts';
+export { CHAIN_BUCKETS, startChainServer } from './startChainServer.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EACL,cAAc,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,cAAc,GACxE,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EACV,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,GACpD,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/node/index.mjs

@@ -0,0 +1,85 @@
+// src/ChainBacking.ts
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var CHAIN_BACKINGS = ["memory"];
+function isChainBackingKind(value) {
+  return CHAIN_BACKINGS.includes(value);
+}
+function createMemoryBacking() {
+  let dir;
+  return {
+    description: "memory (ephemeral temp directory)",
+    get directory() {
+      if (dir === void 0) throw new Error("Memory backing not prepared");
+      return dir;
+    },
+    async prepare() {
+      dir ??= await mkdtemp(path.join(tmpdir(), "aries-chain-"));
+    },
+    async cleanup() {
+      if (dir !== void 0) await rm(dir, { recursive: true, force: true });
+      dir = void 0;
+    }
+  };
+}
+function resolveBacking(kind) {
+  switch (kind) {
+    case "memory": {
+      return createMemoryBacking();
+    }
+  }
+}
+
+// src/startChainServer.ts
+import S3rver from "s3rver";
+var CHAIN_BUCKETS = ["blocks", "state", "indexes"];
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 8791;
+var CORS_ALLOW_READS = `<CORSConfiguration>
+  <CORSRule>
+    <AllowedOrigin>*</AllowedOrigin>
+    <AllowedMethod>GET</AllowedMethod>
+    <AllowedMethod>HEAD</AllowedMethod>
+    <AllowedHeader>*</AllowedHeader>
+  </CORSRule>
+</CORSConfiguration>`;
+async function startChainServer(options) {
+  const host = options.host ?? DEFAULT_HOST;
+  const publicHost = options.publicHost ?? host;
+  await options.backing.prepare();
+  const server = new S3rver({
+    address: host,
+    allowMismatchedSignatures: true,
+    cert: options.tls?.cert,
+    configureBuckets: CHAIN_BUCKETS.map((name) => ({ name, configs: [CORS_ALLOW_READS] })),
+    directory: options.backing.directory,
+    key: options.tls?.key,
+    port: options.port ?? DEFAULT_PORT,
+    silent: options.silent ?? false,
+    vhostBuckets: false
+  });
+  try {
+    const { port } = await server.run();
+    return {
+      baseUrl: `${options.tls === void 0 ? "http" : "https"}://${publicHost}:${port}`,
+      port,
+      close: async () => {
+        await server.close();
+        await options.backing.cleanup();
+      }
+    };
+  } catch (error) {
+    await options.backing.cleanup();
+    throw error;
+  }
+}
+export {
+  CHAIN_BACKINGS,
+  CHAIN_BUCKETS,
+  createMemoryBacking,
+  isChainBackingKind,
+  resolveBacking,
+  startChainServer
+};
+//# sourceMappingURL=index.mjs.map

package/dist/node/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ChainBacking.ts", "../../src/startChainServer.ts"],
+  "sourcesContent": ["import { mkdtemp, rm } from 'node:fs/promises'\nimport { tmpdir } from 'node:os'\nimport path from 'node:path'\n\nexport const CHAIN_BACKINGS = ['memory'] as const\nexport type ChainBackingKind = typeof CHAIN_BACKINGS[number]\n\nexport function isChainBackingKind(value: string): value is ChainBackingKind {\n  return (CHAIN_BACKINGS as readonly string[]).includes(value)\n}\n\n/**\n * Where the served chain layout's objects live. v1 ships only `memory` (an\n * ephemeral temp directory wiped on shutdown); a `disk` kind (caller-owned\n * directory, no-op cleanup) is the natural next addition. An `s3` kind will\n * proxy a remote bucket instead of running a local store, so it will lift\n * this seam up to the server level rather than fit this interface.\n */\nexport interface ChainBacking {\n  /** Human-readable label for banners and status output. */\n  readonly description: string\n  /** Directory the S3-compatible server persists bucket objects under. Only valid after prepare(). */\n  readonly directory: string\n  cleanup(): Promise<void>\n  prepare(): Promise<void>\n}\n\nexport function createMemoryBacking(): ChainBacking {\n  let dir: string | undefined\n  return {\n    description: 'memory (ephemeral temp directory)',\n    get directory(): string {\n      if (dir === undefined) throw new Error('Memory backing not prepared')\n      return dir\n    },\n    async prepare(): Promise<void> {\n      dir ??= await mkdtemp(path.join(tmpdir(), 'aries-chain-'))\n    },\n    async cleanup(): Promise<void> {\n      if (dir !== undefined) await rm(dir, { recursive: true, force: true })\n      dir = undefined\n    },\n  }\n}\n\nexport function resolveBacking(kind: ChainBackingKind): ChainBacking {\n  switch (kind) {\n    case 'memory': {\n      return createMemoryBacking()\n    }\n  }\n}\n", "import S3rver from 's3rver'\n\nimport type { ChainBacking } from './ChainBacking.ts'\n\n/**\n * The bucket-per-role split of the published chain layout. Path-style\n * addressing turns each bucket into a subfolder of the one origin \u2014\n * `/blocks`, `/state`, `/indexes` \u2014 replacing the production sub-domains.\n */\nexport const CHAIN_BUCKETS = ['blocks', 'state', 'indexes'] as const\nexport type ChainBucket = typeof CHAIN_BUCKETS[number]\n\nconst DEFAULT_HOST = '127.0.0.1'\nconst DEFAULT_PORT = 8791\n\n/** Allow browser RestBlockViewer clients to read the layout cross-origin. */\nconst CORS_ALLOW_READS = `<CORSConfiguration>\n  <CORSRule>\n    <AllowedOrigin>*</AllowedOrigin>\n    <AllowedMethod>GET</AllowedMethod>\n    <AllowedMethod>HEAD</AllowedMethod>\n    <AllowedHeader>*</AllowedHeader>\n  </CORSRule>\n</CORSConfiguration>`\n\nexport interface ChainServerOptions {\n  backing: ChainBacking\n  host?: string\n  port?: number\n  publicHost?: string\n  silent?: boolean\n  tls?: {\n    cert: string | Buffer\n    key: string | Buffer\n  }\n}\n\nexport interface RunningChainServer {\n  baseUrl: string\n  port: number\n  close(): Promise<void>\n}\n\n/**\n * Boots an S3-compatible server (s3rver) pre-configured with the three chain\n * layout buckets. Writers use the S3 API (any credentials are accepted);\n * readers fetch `/{bucket}/{layout-path}` over HTTP or optional TLS.\n *\n * DEV ONLY \u2014 this server is a local development fixture, not a production\n * chain host. It intentionally skips the production concerns the datalake\n * and signing-pool planes carry (auth, metrics, durable multi-instance\n * storage): any S3 credentials are accepted and the only backing is an\n * ephemeral temp directory. Production chains stay on the real sub-domain\n * layout (blocks/state/indexes origins backed by S3/R2).\n */\nexport async function startChainServer(options: ChainServerOptions): Promise<RunningChainServer> {\n  const host = options.host ?? DEFAULT_HOST\n  const publicHost = options.publicHost ?? host\n  await options.backing.prepare()\n  const server = new S3rver({\n    address: host,\n    allowMismatchedSignatures: true,\n    cert: options.tls?.cert,\n    configureBuckets: CHAIN_BUCKETS.map(name => ({ name, configs: [CORS_ALLOW_READS] })),\n    directory: options.backing.directory,\n    key: options.tls?.key,\n    port: options.port ?? DEFAULT_PORT,\n    silent: options.silent ?? false,\n    vhostBuckets: false,\n  })\n  try {\n    const { port } = await server.run()\n    return {\n      baseUrl: `${options.tls === undefined ? 'http' : 'https'}://${publicHost}:${port}`,\n      port,\n      close: async (): Promise<void> => {\n        await server.close()\n        await options.backing.cleanup()\n      },\n    }\n  } catch (error) {\n    await options.backing.cleanup()\n    throw error\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,SAAS,UAAU;AAC5B,SAAS,cAAc;AACvB,OAAO,UAAU;AAEV,IAAM,iBAAiB,CAAC,QAAQ;AAGhC,SAAS,mBAAmB,OAA0C;AAC3E,SAAQ,eAAqC,SAAS,KAAK;AAC7D;AAkBO,SAAS,sBAAoC;AAClD,MAAI;AACJ,SAAO;AAAA,IACL,aAAa;AAAA,IACb,IAAI,YAAoB;AACtB,UAAI,QAAQ,OAAW,OAAM,IAAI,MAAM,6BAA6B;AACpE,aAAO;AAAA,IACT;AAAA,IACA,MAAM,UAAyB;AAC7B,cAAQ,MAAM,QAAQ,KAAK,KAAK,OAAO,GAAG,cAAc,CAAC;AAAA,IAC3D;AAAA,IACA,MAAM,UAAyB;AAC7B,UAAI,QAAQ,OAAW,OAAM,GAAG,KAAK,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AACrE,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAEO,SAAS,eAAe,MAAsC;AACnE,UAAQ,MAAM;AAAA,IACZ,KAAK,UAAU;AACb,aAAO,oBAAoB;AAAA,IAC7B;AAAA,EACF;AACF;;;ACnDA,OAAO,YAAY;AASZ,IAAM,gBAAgB,CAAC,UAAU,SAAS,SAAS;AAG1D,IAAM,eAAe;AACrB,IAAM,eAAe;AAGrB,IAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuCzB,eAAsB,iBAAiB,SAA0D;AAC/F,QAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,QAAQ,QAAQ,QAAQ;AAC9B,QAAM,SAAS,IAAI,OAAO;AAAA,IACxB,SAAS;AAAA,IACT,2BAA2B;AAAA,IAC3B,MAAM,QAAQ,KAAK;AAAA,IACnB,kBAAkB,cAAc,IAAI,WAAS,EAAE,MAAM,SAAS,CAAC,gBAAgB,EAAE,EAAE;AAAA,IACnF,WAAW,QAAQ,QAAQ;AAAA,IAC3B,KAAK,QAAQ,KAAK;AAAA,IAClB,MAAM,QAAQ,QAAQ;AAAA,IACtB,QAAQ,QAAQ,UAAU;AAAA,IAC1B,cAAc;AAAA,EAChB,CAAC;AACD,MAAI;AACF,UAAM,EAAE,KAAK,IAAI,MAAM,OAAO,IAAI;AAClC,WAAO;AAAA,MACL,SAAS,GAAG,QAAQ,QAAQ,SAAY,SAAS,OAAO,MAAM,UAAU,IAAI,IAAI;AAAA,MAChF;AAAA,MACA,OAAO,YAA2B;AAChC,cAAM,OAAO,MAAM;AACnB,cAAM,QAAQ,QAAQ,QAAQ;AAAA,MAChC;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,UAAM,QAAQ,QAAQ,QAAQ;AAC9B,UAAM;AAAA,EACR;AACF;",
+  "names": []
+}

package/dist/node/startChainServer.d.ts

@@ -0,0 +1,38 @@
+import type { ChainBacking } from './ChainBacking.ts';
+/**
+ * The bucket-per-role split of the published chain layout. Path-style
+ * addressing turns each bucket into a subfolder of the one origin —
+ * `/blocks`, `/state`, `/indexes` — replacing the production sub-domains.
+ */
+export declare const CHAIN_BUCKETS: readonly ["blocks", "state", "indexes"];
+export type ChainBucket = typeof CHAIN_BUCKETS[number];
+export interface ChainServerOptions {
+    backing: ChainBacking;
+    host?: string;
+    port?: number;
+    publicHost?: string;
+    silent?: boolean;
+    tls?: {
+        cert: string | Buffer;
+        key: string | Buffer;
+    };
+}
+export interface RunningChainServer {
+    baseUrl: string;
+    port: number;
+    close(): Promise<void>;
+}
+/**
+ * Boots an S3-compatible server (s3rver) pre-configured with the three chain
+ * layout buckets. Writers use the S3 API (any credentials are accepted);
+ * readers fetch `/{bucket}/{layout-path}` over HTTP or optional TLS.
+ *
+ * DEV ONLY — this server is a local development fixture, not a production
+ * chain host. It intentionally skips the production concerns the datalake
+ * and signing-pool planes carry (auth, metrics, durable multi-instance
+ * storage): any S3 credentials are accepted and the only backing is an
+ * ephemeral temp directory. Production chains stay on the real sub-domain
+ * layout (blocks/state/indexes origins backed by S3/R2).
+ */
+export declare function startChainServer(options: ChainServerOptions): Promise<RunningChainServer>;
+//# sourceMappingURL=startChainServer.d.ts.map

package/dist/node/startChainServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startChainServer.d.ts","sourceRoot":"","sources":["../../src/startChainServer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;GAIG;AACH,eAAO,MAAM,aAAa,yCAA0C,CAAA;AACpE,MAAM,MAAM,WAAW,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAetD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,YAAY,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE;QACJ,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;QACrB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KACrB,CAAA;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6B/F"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@ariestools/aries-chain-serve",
+  "version": "0.1.14",
+  "description": "Aries chain REST server: serves the XL1 published-chain S3 layout from one origin with /blocks, /state, /indexes subfolders",
+  "keywords": [
+    "ariestools",
+    "xl1",
+    "xyo",
+    "chain",
+    "blockviewer",
+    "s3",
+    "typescript"
+  ],
+  "homepage": "https://ariestools.ai",
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "Arie Trouw",
+    "email": "support@ariestools.ai",
+    "url": "https://ariestools.ai"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "aries-chain-serve": "dist/bin/chainServer.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "s3rver": "~3.7.1"
+  },
+  "devDependencies": {
+    "@ariestools/toolchain": "~8.7.22",
+    "@ariestools/tsconfig": "~8.7.22",
+    "@aws-sdk/client-s3": "~3.1091.0",
+    "@types/node": "~26.1.1",
+    "@types/s3rver": "~3.7.4",
+    "rolldown": "~1.2.0",
+    "typescript": "~6.0.3",
+    "vite": "~8.1.5",
+    "vitest": "~4.1.10"
+  },
+  "engines": {
+    "node": ">=18.17.1"
+  },
+  "engineStrict": true,
+  "scripts": {
+    "package-compile": "package-compile-only && rolldown -c rolldown.config.ts"
+  }
+}