@ariestools/aries-dapp-core 0.1.7

package/README.md

@@ -0,0 +1,38 @@
+# @ariestools/aries-dapp-core
+
+> **Dev only.** This is the compute half of the local `aries dapp` backend, a
+> development fixture with no auth or metrics and memory-only storage. Not for
+> production at this time.
+
+The brains of a local dapp backend. It pairs with the storage server in
+[`@ariestools/aries-dapp-serve`](../dapp-serve): the server holds three buckets
+(`data`, `state`, `index`), and this package derives the mutable buckets from
+the immutable one on an interval.
+
+## Pieces
+
+- **`AbstractActor`** — a lean, dapp-owned fork of the xl1 `ActorV3` pattern:
+  the `create`/`start`/`stop` lifecycle plus non-overlapping interval timers
+  (`registerTimer`) and a readiness contract. It swaps the chain's
+  `ProviderFactoryLocator`/`LocatorConfig` machinery for the small
+  `DappProviderLocator` seam, so an actor resolves providers by moniker without
+  the chain protocol config model. Intended to graduate into a shared cli/actor
+  toolkit — and, later, xl1-protocol — where it can re-adopt the real locator.
+- **`DappProviderLocator` / `createDappLocator`** — the **process-wide** service
+  locator, built once and shared across every actor (xl1-cli style). It
+  pre-registers an S3-backed `DappBucketStore` per bucket keyed by moniker.
+- **`DappActor`** — resolves the three stores from the locator and drives its
+  `DappReducer` on an interval to keep `state`/`index` derived from `data`.
+- **`DappReducer`** — the pluggable unit of dapp logic (`reduce({data, state,
+  index, logger})`). `noopReducer` is the default; supply a real one to derive.
+- **`bootDappActors`** — creates and starts N actors against one shared locator.
+
+## Daemon
+
+The composed daemon bin (`dist/bin/dappServer.mjs`) starts the storage server
+and, in the same process, the locator and actors. `aries dapp up` spawns it.
+Env config: `DAPP_PORT` (default 8801), `HOST` (default 127.0.0.1),
+`DAPP_BACKING` (default `memory`), `DAPP_PUBLIC_HOST`, `DAPP_TLS_CERT`,
+`DAPP_TLS_KEY`, and `DAPP_REDUCE_INTERVAL_MS` (default 5000). Under
+`--ssl auto` the daemon exports the local CA via `NODE_EXTRA_CA_CERTS` so the
+in-process S3 client trusts the HTTPS origin.

package/dist/bin/dappServer.mjs

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { DAPP_BACKINGS, DAPP_BUCKETS, isDappBackingKind, resolveBacking, startDappServer } from "@ariestools/aries-dapp-serve";
+import { AbstractCreatable, ConsoleLogger, IdLogger, assertEx, creatable } from "@ariestools/sdk";
+import { GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+//#region src/actor/AbstractActor.ts
+function createDeferred() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		reject,
+		resolve
+	};
+}
+/**
+* Lean, dapp-owned fork of the xl1 `ActorV3` pattern: the create/start/stop
+* lifecycle from `AbstractCreatable`, plus non-overlapping interval timers and
+* a readiness contract. It deliberately swaps the chain's
+* `ProviderFactoryLocator`/`LocatorConfig` machinery for the small
+* {@link DappProviderLocator} seam, so a dapp actor resolves providers by
+* moniker without dragging the chain protocol config model in.
+*
+* The locator is process-wide: the daemon builds it once and passes the same
+* instance to every actor via `params.locator` (see `bootDappActors`). When
+* this graduates into a shared cli/actor toolkit — and, later, xl1-protocol —
+* this base can re-adopt the real locator.
+*/
+var AbstractActor = class extends AbstractCreatable {
+	_intervals = /* @__PURE__ */ new Map();
+	_timeouts = /* @__PURE__ */ new Map();
+	_idLogger;
+	_inFlight = /* @__PURE__ */ new Map();
+	_readyDeferred = createDeferred();
+	_readyError;
+	_readyState = "pending";
+	get logger() {
+		this._idLogger ??= new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name);
+		return this._idLogger;
+	}
+	get readyError() {
+		return this._readyError;
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	get context() {
+		return this.locator.context;
+	}
+	get locator() {
+		return this.params.locator;
+	}
+	static async paramsHandler(params) {
+		const inParams = params ?? {};
+		const baseParams = await super.paramsHandler({
+			...inParams,
+			name: inParams.name ?? "UnknownActor"
+		});
+		const locator = assertEx(inParams.locator, () => `params.locator is required for actor ${String(baseParams.name)}.`);
+		return {
+			...baseParams,
+			locator
+		};
+	}
+	/**
+	* Register a recurring task. The interval only fires while the actor is
+	* `started`, and a run is skipped if the previous one is still in flight, so
+	* a slow pass can never stack on top of itself. Must be called from
+	* `startHandler` (guards on `starting` status), mirroring the xl1 actor.
+	*/
+	registerTimer(timerName, callback, dueTimeMs, periodMs) {
+		if (this.status !== "starting") {
+			this.logger.warn(`Cannot register timer '${timerName}' because actor is not starting.`);
+			return;
+		}
+		const tick = () => {
+			if (this.status !== "started" || !this._intervals.has(timerName)) return;
+			if (this._inFlight.has(timerName)) {
+				this.logger.warn(`Skipping timer '${this.name}:${timerName}' because the previous run is still in flight.`);
+				return;
+			}
+			const run = (async () => {
+				const startTime = Date.now();
+				try {
+					await callback();
+				} catch (error) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					this.logger.error(`Error in timer '${this.name}:${timerName}': ${err.message}`);
+				} finally {
+					const duration = Date.now() - startTime;
+					if (duration > periodMs) this.logger.warn(`Timer '${this.name}:${timerName}' took ${duration}ms, longer than its ${periodMs}ms period.`);
+				}
+			})();
+			this._inFlight.set(timerName, run.finally(() => {
+				this._inFlight.delete(timerName);
+			}));
+		};
+		const timeoutId = setTimeout(() => {
+			this._intervals.set(timerName, setInterval(tick, periodMs));
+		}, dueTimeMs);
+		this._timeouts.set(timerName, timeoutId);
+	}
+	/**
+	* Run the warm-pass once. Not driven automatically here (no orchestrator);
+	* a caller invokes it after `start()` if it wants `whenReady()` to resolve.
+	*/
+	async runReadyHandler() {
+		if (this._readyState !== "pending") return;
+		try {
+			await this.readyHandler();
+			this._readyState = "ready";
+			this._readyDeferred.resolve();
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this._readyState = "failed";
+			this._readyError = err;
+			this._readyDeferred.reject(err);
+			throw err;
+		}
+	}
+	async stopHandler() {
+		await super.stopHandler();
+		for (const timeoutRef of this._timeouts.values()) clearTimeout(timeoutRef);
+		this._timeouts.clear();
+		for (const intervalRef of this._intervals.values()) clearInterval(intervalRef);
+		this._intervals.clear();
+		await Promise.allSettled(this._inFlight.values());
+		this._inFlight.clear();
+	}
+	async whenReady() {
+		await this._readyDeferred.promise;
+	}
+	/** Override to prove the actor can do useful work. Default: no-op. */
+	async readyHandler() {}
+};
+//#endregion
+//#region src/providers/monikers.ts
+/**
+* Provider monikers for the three dapp buckets. An actor declares these in its
+* `static dependencies` and resolves them from the locator at create time.
+*/
+const DappDataStoreMoniker = "DappDataStore";
+const DappStateStoreMoniker = "DappStateStore";
+const DappIndexStoreMoniker = "DappIndexStore";
+//#endregion
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/DappActor.ts
+const DEFAULT_REDUCE_INTERVAL_MS = 5e3;
+const DEFAULT_FIRST_RUN_DELAY_MS = 2e3;
+let DappActor = class DappActor extends AbstractActor {
+	static dependencies = [
+		DappDataStoreMoniker,
+		DappStateStoreMoniker,
+		DappIndexStoreMoniker
+	];
+	_data;
+	_index;
+	_state;
+	async createHandler() {
+		await super.createHandler();
+		this._data = await this.locator.getInstance(DappDataStoreMoniker);
+		this._state = await this.locator.getInstance(DappStateStoreMoniker);
+		this._index = await this.locator.getInstance(DappIndexStoreMoniker);
+	}
+	async startHandler() {
+		await super.startHandler();
+		const interval = this.params.reduceIntervalMs ?? DEFAULT_REDUCE_INTERVAL_MS;
+		const firstRunDelay = this.params.firstRunDelayMs ?? DEFAULT_FIRST_RUN_DELAY_MS;
+		this.registerTimer("DappReduce", async () => {
+			await this.runReducePass();
+		}, firstRunDelay, interval);
+		this.logger.info(`DappActor started: reducer '${this.params.reducer.name}' every ${interval}ms`);
+	}
+	async runReducePass() {
+		await this.params.reducer.reduce({
+			data: this._data,
+			index: this._index,
+			logger: this.logger,
+			state: this._state
+		});
+	}
+};
+DappActor = __decorate([creatable()], DappActor);
+//#endregion
+//#region src/boot/bootDappActors.ts
+/**
+* Creates and starts one {@link DappActor} per spec, all sharing the single
+* process-wide locator. Returns them so the caller can stop them on shutdown.
+*/
+async function bootDappActors(locator, specs) {
+	const actors = [];
+	for (const spec of specs) {
+		const params = {
+			locator,
+			name: spec.name,
+			reducer: spec.reducer,
+			...spec.reduceIntervalMs !== void 0 && { reduceIntervalMs: spec.reduceIntervalMs }
+		};
+		const actor = await DappActor.create(params);
+		await actor.start();
+		actors.push(actor);
+	}
+	return actors;
+}
+//#endregion
+//#region src/providers/DappBucketStore.ts
+const DEFAULT_CREDENTIAL = "S3RVER";
+function isNotFound(error) {
+	const name = error.name;
+	return name === "NoSuchKey" || name === "NotFound";
+}
+/**
+* S3-backed {@link DappBucketStore} pointed at the local dapp server. Uses
+* path-style addressing so `/{bucket}/{key}` resolves as a subfolder of the
+* one origin. Under `--ssl auto` the server speaks HTTPS with a locally
+* trusted certificate; the daemon exports its CA via `NODE_EXTRA_CA_CERTS`, so
+* this client trusts it without any per-request handler configuration.
+*/
+function createS3BucketStore(options) {
+	const { bucket } = options;
+	const client = new S3Client({
+		endpoint: options.endpoint,
+		region: "us-east-1",
+		forcePathStyle: true,
+		credentials: {
+			accessKeyId: options.accessKeyId ?? DEFAULT_CREDENTIAL,
+			secretAccessKey: options.secretAccessKey ?? DEFAULT_CREDENTIAL
+		}
+	});
+	return {
+		bucket,
+		async get(key) {
+			try {
+				return await (await client.send(new GetObjectCommand({
+					Bucket: bucket,
+					Key: key
+				}))).Body?.transformToByteArray();
+			} catch (error) {
+				if (isNotFound(error)) return void 0;
+				throw error;
+			}
+		},
+		async put(key, body) {
+			await client.send(new PutObjectCommand({
+				Bucket: bucket,
+				Key: key,
+				Body: body
+			}));
+		},
+		async list(prefix) {
+			const keys = [];
+			let token;
+			do {
+				const response = await client.send(new ListObjectsV2Command({
+					Bucket: bucket,
+					Prefix: prefix,
+					ContinuationToken: token
+				}));
+				for (const item of response.Contents ?? []) if (item.Key !== void 0) keys.push(item.Key);
+				token = response.IsTruncated === true ? response.NextContinuationToken : void 0;
+			} while (token !== void 0);
+			return keys;
+		}
+	};
+}
+//#endregion
+//#region src/locator/createDappLocator.ts
+/**
+* Builds the process-wide locator: one instance, shared across every actor
+* (xl1-cli style). It pre-registers an S3-backed store per bucket keyed by
+* moniker; extra providers can be `register`ed before actors are created.
+*/
+function createDappLocator(options) {
+	const logger = options.logger ?? new ConsoleLogger();
+	const bucketOptions = {
+		endpoint: options.endpoint,
+		...options.accessKeyId !== void 0 && { accessKeyId: options.accessKeyId },
+		...options.secretAccessKey !== void 0 && { secretAccessKey: options.secretAccessKey }
+	};
+	const instances = /* @__PURE__ */ new Map([
+		[DappDataStoreMoniker, createS3BucketStore({
+			...bucketOptions,
+			bucket: "data"
+		})],
+		[DappStateStoreMoniker, createS3BucketStore({
+			...bucketOptions,
+			bucket: "state"
+		})],
+		[DappIndexStoreMoniker, createS3BucketStore({
+			...bucketOptions,
+			bucket: "index"
+		})]
+	]);
+	return {
+		context: { logger },
+		has(moniker) {
+			return instances.has(moniker);
+		},
+		register(moniker, instance) {
+			instances.set(moniker, instance);
+		},
+		async getInstance(moniker) {
+			const found = instances.get(moniker);
+			if (found === void 0) throw new Error(`No provider registered for moniker "${moniker}"`);
+			return found;
+		},
+		async tryGetInstance(moniker) {
+			return instances.get(moniker);
+		}
+	};
+}
+//#endregion
+//#region src/reducer/DappReducer.ts
+/**
+* Default reducer: does nothing. The harness runs the full timer/provider
+* spine with this in place; supply a real reducer to derive `state` and
+* `index` from `data`.
+*/
+const noopReducer = {
+	name: "noop",
+	async reduce() {}
+};
+//#endregion
+//#region src/bin/dappServer.ts
+/**
+* Composed dapp daemon: boots the S3-compatible storage server (from
+* `@ariestools/aries-dapp-serve`) and, in the same process, a shared
+* process-wide locator plus the DappActor(s) that derive `state`/`index` from
+* `data` on an interval. Spawned by `aries dapp up`.
+*/
+const PORT = Number(process.env.DAPP_PORT ?? 8801);
+const HOST = process.env.HOST ?? "127.0.0.1";
+const BACKING = process.env.DAPP_BACKING ?? "memory";
+const PUBLIC_HOST = process.env.DAPP_PUBLIC_HOST;
+const TLS_CERT_PATH = process.env.DAPP_TLS_CERT;
+const TLS_KEY_PATH = process.env.DAPP_TLS_KEY;
+const REDUCE_INTERVAL_MS = Number(process.env.DAPP_REDUCE_INTERVAL_MS ?? 5e3);
+async function main() {
+	if (!isDappBackingKind(BACKING)) throw new Error(`Unsupported DAPP_BACKING '${BACKING}' (supported: ${DAPP_BACKINGS.join(", ")})`);
+	if (TLS_CERT_PATH === void 0 !== (TLS_KEY_PATH === void 0)) throw new Error("DAPP_TLS_CERT and DAPP_TLS_KEY must be provided together");
+	const backing = resolveBacking(BACKING);
+	const server = await startDappServer({
+		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)
+		}
+	});
+	const logger = new ConsoleLogger();
+	const actors = await bootDappActors(createDappLocator({
+		endpoint: server.baseUrl,
+		logger
+	}), [{
+		name: "DappActor",
+		reducer: noopReducer,
+		reduceIntervalMs: REDUCE_INTERVAL_MS
+	}]);
+	console.log(`dapp server listening at ${server.baseUrl}\n` + DAPP_BUCKETS.map((bucket) => `  /${bucket.padEnd(5)} ${server.baseUrl}/${bucket}`).join("\n") + `\nbacking: ${backing.description} — ${backing.directory}\nactors: ${actors.length} (reducer '${noopReducer.name}', every ${REDUCE_INTERVAL_MS}ms)`);
+	const shutdown = async () => {
+		for (const actor of actors) await actor.stop();
+		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/DappActor.d.ts

@@ -0,0 +1,26 @@
+import { AbstractActor } from './actor/AbstractActor.ts';
+import type { ActorParams } from './actor/types.ts';
+import type { DappBucketStore } from './providers/DappBucketStore.ts';
+import type { DappReducer } from './reducer/DappReducer.ts';
+export interface DappActorParams extends ActorParams {
+    /** Delay before the first reduce pass. Defaults to 2000ms. */
+    firstRunDelayMs?: number;
+    reduceIntervalMs?: number;
+    reducer: DappReducer;
+}
+/**
+ * The stock dapp actor: resolves the three bucket stores from the shared
+ * locator, then drives its reducer on an interval to keep `state` and `index`
+ * derived from `data`. Multiple actors (each with its own reducer) can share
+ * one locator; this is the default single-reducer instance the daemon boots.
+ */
+export declare class DappActor extends AbstractActor<DappActorParams> {
+    static readonly dependencies: readonly ["DappDataStore", "DappStateStore", "DappIndexStore"];
+    protected _data: DappBucketStore;
+    protected _index: DappBucketStore;
+    protected _state: DappBucketStore;
+    createHandler(): Promise<void>;
+    protected startHandler(): Promise<void>;
+    private runReducePass;
+}
+//# sourceMappingURL=DappActor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DappActor.d.ts","sourceRoot":"","sources":["../../src/DappActor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAIrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAE3D,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,OAAO,EAAE,WAAW,CAAA;CACrB;AAKD;;;;;GAKG;AACH,qBACa,SAAU,SAAQ,aAAa,CAAC,eAAe,CAAC;IAC3D,MAAM,CAAC,QAAQ,CAAC,YAAY,iEAIlB;IAEV,SAAS,CAAC,KAAK,EAAG,eAAe,CAAA;IACjC,SAAS,CAAC,MAAM,EAAG,eAAe,CAAA;IAClC,SAAS,CAAC,MAAM,EAAG,eAAe,CAAA;IAEnB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;cAOpB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;YAUxC,aAAa;CAQ5B"}

package/dist/node/actor/AbstractActor.d.ts

@@ -0,0 +1,48 @@
+import type { CreatableInstance, Logger } from '@ariestools/sdk';
+import { AbstractCreatable } from '@ariestools/sdk';
+import type { ActorParams, DappContext, DappProviderLocator, ReadyState } from './types.ts';
+/**
+ * Lean, dapp-owned fork of the xl1 `ActorV3` pattern: the create/start/stop
+ * lifecycle from `AbstractCreatable`, plus non-overlapping interval timers and
+ * a readiness contract. It deliberately swaps the chain's
+ * `ProviderFactoryLocator`/`LocatorConfig` machinery for the small
+ * {@link DappProviderLocator} seam, so a dapp actor resolves providers by
+ * moniker without dragging the chain protocol config model in.
+ *
+ * The locator is process-wide: the daemon builds it once and passes the same
+ * instance to every actor via `params.locator` (see `bootDappActors`). When
+ * this graduates into a shared cli/actor toolkit — and, later, xl1-protocol —
+ * this base can re-adopt the real locator.
+ */
+export declare abstract class AbstractActor<TParams extends ActorParams = ActorParams> extends AbstractCreatable<TParams> {
+    protected readonly _intervals: Map<string, NodeJS.Timeout>;
+    protected readonly _timeouts: Map<string, NodeJS.Timeout>;
+    private _idLogger?;
+    private readonly _inFlight;
+    private readonly _readyDeferred;
+    private _readyError?;
+    private _readyState;
+    get logger(): Logger;
+    get readyError(): Error | undefined;
+    get readyState(): ReadyState;
+    protected get context(): DappContext;
+    protected get locator(): DappProviderLocator;
+    static paramsHandler<T extends CreatableInstance>(params?: Partial<T['params']>): Promise<T['params']>;
+    /**
+     * Register a recurring task. The interval only fires while the actor is
+     * `started`, and a run is skipped if the previous one is still in flight, so
+     * a slow pass can never stack on top of itself. Must be called from
+     * `startHandler` (guards on `starting` status), mirroring the xl1 actor.
+     */
+    registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number): void;
+    /**
+     * Run the warm-pass once. Not driven automatically here (no orchestrator);
+     * a caller invokes it after `start()` if it wants `whenReady()` to resolve.
+     */
+    runReadyHandler(): Promise<void>;
+    stopHandler(): Promise<void>;
+    whenReady(): Promise<void>;
+    /** Override to prove the actor can do useful work. Default: no-op. */
+    protected readyHandler(): Promise<void>;
+}
+//# sourceMappingURL=AbstractActor.d.ts.map

package/dist/node/actor/AbstractActor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractActor.d.ts","sourceRoot":"","sources":["../../../src/actor/AbstractActor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,EACL,iBAAiB,EAClB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EACV,WAAW,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAC1D,MAAM,YAAY,CAAA;AAoBnB;;;;;;;;;;;;GAYG;AACH,8BAAsB,aAAa,CAAC,OAAO,SAAS,WAAW,GAAG,WAAW,CAAE,SAAQ,iBAAiB,CAAC,OAAO,CAAC;IAC/G,SAAS,CAAC,QAAQ,CAAC,UAAU,8BAAoC;IACjE,SAAS,CAAC,QAAQ,CAAC,SAAS,8BAAoC;IAEhE,OAAO,CAAC,SAAS,CAAC,CAAQ;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyB;IACxD,OAAO,CAAC,WAAW,CAAC,CAAO;IAC3B,OAAO,CAAC,WAAW,CAAwB;IAE3C,IAAa,MAAM,IAAI,MAAM,CAM5B;IAED,IAAI,UAAU,IAAI,KAAK,GAAG,SAAS,CAElC;IAED,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED,SAAS,KAAK,OAAO,IAAI,WAAW,CAEnC;IAED,SAAS,KAAK,OAAO,IAAI,mBAAmB,CAE3C;WAEqB,aAAa,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IAOrH;;;;;OAKG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAmC1G;;;OAGG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAevB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAUrC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC,sEAAsE;cACtD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9C"}

package/dist/node/actor/types.d.ts

@@ -0,0 +1,30 @@
+import type { CreatableParams, Logger } from '@ariestools/sdk';
+/** Identifier a provider is registered and resolved under in the locator. */
+export type DappMoniker = string;
+export type ReadyState = 'pending' | 'ready' | 'failed';
+/**
+ * The shared context carried by the process-wide locator. Kept intentionally
+ * minimal — a `logger` is all an actor requires. Telemetry (meter/tracer) can
+ * be added here when the base graduates into the shared cli/actor toolkit.
+ */
+export interface DappContext {
+    logger: Logger;
+}
+/**
+ * Small service-locator seam an actor uses to resolve its providers by moniker.
+ * A dapp-owned stand-in for the chain's `ProviderFactoryLocatorInstance` that
+ * avoids the chain `LocatorConfig`/protocol coupling. The daemon builds one and
+ * shares the same instance across every actor (see `bootDappActors`).
+ */
+export interface DappProviderLocator {
+    readonly context: DappContext;
+    getInstance<T>(moniker: DappMoniker): Promise<T>;
+    has(moniker: DappMoniker): boolean;
+    register(moniker: DappMoniker, instance: unknown): void;
+    tryGetInstance<T>(moniker: DappMoniker): Promise<T | undefined>;
+}
+/** Base params every dapp actor takes: the shared, process-wide locator. */
+export interface ActorParams extends CreatableParams {
+    locator: DappProviderLocator;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/node/actor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/actor/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAE9D,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG,MAAM,CAAA;AAEhC,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEvD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAChD,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAA;IACvD,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;CAChE;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAY,SAAQ,eAAe;IAClD,OAAO,EAAE,mBAAmB,CAAA;CAC7B"}

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Composed dapp daemon: boots the S3-compatible storage server (from
+ * `@ariestools/aries-dapp-serve`) and, in the same process, a shared
+ * process-wide locator plus the DappActor(s) that derive `state`/`index` from
+ * `data` on an interval. Spawned by `aries dapp up`.
+ */
+export {};
+//# sourceMappingURL=dappServer.d.ts.map

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

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

package/dist/node/boot/bootDappActors.d.ts

@@ -0,0 +1,14 @@
+import type { DappProviderLocator } from '../actor/types.ts';
+import { DappActor } from '../DappActor.ts';
+import type { DappReducer } from '../reducer/DappReducer.ts';
+export interface DappActorSpec {
+    name: string;
+    reduceIntervalMs?: number;
+    reducer: DappReducer;
+}
+/**
+ * Creates and starts one {@link DappActor} per spec, all sharing the single
+ * process-wide locator. Returns them so the caller can stop them on shutdown.
+ */
+export declare function bootDappActors(locator: DappProviderLocator, specs: readonly DappActorSpec[]): Promise<DappActor[]>;
+//# sourceMappingURL=bootDappActors.d.ts.map

package/dist/node/boot/bootDappActors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootDappActors.d.ts","sourceRoot":"","sources":["../../../src/boot/bootDappActors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAE5D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,OAAO,EAAE,WAAW,CAAA;CACrB;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,SAAS,aAAa,EAAE,GAC9B,OAAO,CAAC,SAAS,EAAE,CAAC,CActB"}

package/dist/node/index.d.ts

@@ -0,0 +1,14 @@
+export { AbstractActor } from './actor/AbstractActor.ts';
+export type { ActorParams, DappContext, DappMoniker, DappProviderLocator, ReadyState, } from './actor/types.ts';
+export type { DappActorSpec } from './boot/bootDappActors.ts';
+export { bootDappActors } from './boot/bootDappActors.ts';
+export type { DappActorParams } from './DappActor.ts';
+export { DappActor } from './DappActor.ts';
+export type { CreateDappLocatorOptions } from './locator/createDappLocator.ts';
+export { createDappLocator } from './locator/createDappLocator.ts';
+export type { DappBucketStore, S3DappBucketStoreOptions } from './providers/DappBucketStore.ts';
+export { createS3BucketStore } from './providers/DappBucketStore.ts';
+export { DappDataStoreMoniker, DappIndexStoreMoniker, DappStateStoreMoniker, } from './providers/monikers.ts';
+export type { DappReduceContext, DappReducer } from './reducer/DappReducer.ts';
+export { noopReducer } from './reducer/DappReducer.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,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,YAAY,EACV,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,GACvE,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,YAAY,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAClE,YAAY,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAA;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EACL,oBAAoB,EAAE,qBAAqB,EAAE,qBAAqB,GACnE,MAAM,yBAAyB,CAAA;AAChC,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/node/index.mjs

@@ -0,0 +1,318 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/actor/AbstractActor.ts
+import {
+  AbstractCreatable,
+  assertEx,
+  IdLogger
+} from "@ariestools/sdk";
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    reject,
+    resolve
+  };
+}
+var AbstractActor = class extends AbstractCreatable {
+  _intervals = /* @__PURE__ */ new Map();
+  _timeouts = /* @__PURE__ */ new Map();
+  _idLogger;
+  _inFlight = /* @__PURE__ */ new Map();
+  _readyDeferred = createDeferred();
+  _readyError;
+  _readyState = "pending";
+  get logger() {
+    this._idLogger ??= new IdLogger(
+      assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`),
+      () => this.name
+    );
+    return this._idLogger;
+  }
+  get readyError() {
+    return this._readyError;
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  get context() {
+    return this.locator.context;
+  }
+  get locator() {
+    return this.params.locator;
+  }
+  static async paramsHandler(params) {
+    const inParams = params ?? {};
+    const baseParams = await super.paramsHandler({ ...inParams, name: inParams.name ?? "UnknownActor" });
+    const locator = assertEx(inParams.locator, () => `params.locator is required for actor ${String(baseParams.name)}.`);
+    return { ...baseParams, locator };
+  }
+  /**
+   * Register a recurring task. The interval only fires while the actor is
+   * `started`, and a run is skipped if the previous one is still in flight, so
+   * a slow pass can never stack on top of itself. Must be called from
+   * `startHandler` (guards on `starting` status), mirroring the xl1 actor.
+   */
+  registerTimer(timerName, callback, dueTimeMs, periodMs) {
+    if (this.status !== "starting") {
+      this.logger.warn(`Cannot register timer '${timerName}' because actor is not starting.`);
+      return;
+    }
+    const tick = () => {
+      if (this.status !== "started" || !this._intervals.has(timerName)) return;
+      if (this._inFlight.has(timerName)) {
+        this.logger.warn(`Skipping timer '${this.name}:${timerName}' because the previous run is still in flight.`);
+        return;
+      }
+      const run = (async () => {
+        const startTime = Date.now();
+        try {
+          await callback();
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.logger.error(`Error in timer '${this.name}:${timerName}': ${err.message}`);
+        } finally {
+          const duration = Date.now() - startTime;
+          if (duration > periodMs) {
+            this.logger.warn(`Timer '${this.name}:${timerName}' took ${duration}ms, longer than its ${periodMs}ms period.`);
+          }
+        }
+      })();
+      this._inFlight.set(timerName, run.finally(() => {
+        this._inFlight.delete(timerName);
+      }));
+    };
+    const timeoutId = setTimeout(() => {
+      this._intervals.set(timerName, setInterval(tick, periodMs));
+    }, dueTimeMs);
+    this._timeouts.set(timerName, timeoutId);
+  }
+  /**
+   * Run the warm-pass once. Not driven automatically here (no orchestrator);
+   * a caller invokes it after `start()` if it wants `whenReady()` to resolve.
+   */
+  async runReadyHandler() {
+    if (this._readyState !== "pending") return;
+    try {
+      await this.readyHandler();
+      this._readyState = "ready";
+      this._readyDeferred.resolve();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this._readyState = "failed";
+      this._readyError = err;
+      this._readyDeferred.reject(err);
+      throw err;
+    }
+  }
+  async stopHandler() {
+    await super.stopHandler();
+    for (const timeoutRef of this._timeouts.values()) clearTimeout(timeoutRef);
+    this._timeouts.clear();
+    for (const intervalRef of this._intervals.values()) clearInterval(intervalRef);
+    this._intervals.clear();
+    await Promise.allSettled(this._inFlight.values());
+    this._inFlight.clear();
+  }
+  async whenReady() {
+    await this._readyDeferred.promise;
+  }
+  /** Override to prove the actor can do useful work. Default: no-op. */
+  async readyHandler() {
+  }
+};
+
+// src/DappActor.ts
+import { creatable } from "@ariestools/sdk";
+
+// src/providers/monikers.ts
+var DappDataStoreMoniker = "DappDataStore";
+var DappStateStoreMoniker = "DappStateStore";
+var DappIndexStoreMoniker = "DappIndexStore";
+
+// src/DappActor.ts
+var DEFAULT_REDUCE_INTERVAL_MS = 5e3;
+var DEFAULT_FIRST_RUN_DELAY_MS = 2e3;
+var DappActor = class extends AbstractActor {
+  _data;
+  _index;
+  _state;
+  async createHandler() {
+    await super.createHandler();
+    this._data = await this.locator.getInstance(DappDataStoreMoniker);
+    this._state = await this.locator.getInstance(DappStateStoreMoniker);
+    this._index = await this.locator.getInstance(DappIndexStoreMoniker);
+  }
+  async startHandler() {
+    await super.startHandler();
+    const interval = this.params.reduceIntervalMs ?? DEFAULT_REDUCE_INTERVAL_MS;
+    const firstRunDelay = this.params.firstRunDelayMs ?? DEFAULT_FIRST_RUN_DELAY_MS;
+    this.registerTimer("DappReduce", async () => {
+      await this.runReducePass();
+    }, firstRunDelay, interval);
+    this.logger.info(`DappActor started: reducer '${this.params.reducer.name}' every ${interval}ms`);
+  }
+  async runReducePass() {
+    await this.params.reducer.reduce({
+      data: this._data,
+      index: this._index,
+      logger: this.logger,
+      state: this._state
+    });
+  }
+};
+__publicField(DappActor, "dependencies", [
+  DappDataStoreMoniker,
+  DappStateStoreMoniker,
+  DappIndexStoreMoniker
+]);
+DappActor = __decorateClass([
+  creatable()
+], DappActor);
+
+// src/boot/bootDappActors.ts
+async function bootDappActors(locator, specs) {
+  const actors = [];
+  for (const spec of specs) {
+    const params = {
+      locator,
+      name: spec.name,
+      reducer: spec.reducer,
+      ...spec.reduceIntervalMs !== void 0 && { reduceIntervalMs: spec.reduceIntervalMs }
+    };
+    const actor = await DappActor.create(params);
+    await actor.start();
+    actors.push(actor);
+  }
+  return actors;
+}
+
+// src/locator/createDappLocator.ts
+import { ConsoleLogger } from "@ariestools/sdk";
+
+// src/providers/DappBucketStore.ts
+import {
+  GetObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+var DEFAULT_CREDENTIAL = "S3RVER";
+function isNotFound(error) {
+  const name = error.name;
+  return name === "NoSuchKey" || name === "NotFound";
+}
+function createS3BucketStore(options) {
+  const { bucket } = options;
+  const client = new S3Client({
+    endpoint: options.endpoint,
+    region: "us-east-1",
+    forcePathStyle: true,
+    credentials: {
+      accessKeyId: options.accessKeyId ?? DEFAULT_CREDENTIAL,
+      secretAccessKey: options.secretAccessKey ?? DEFAULT_CREDENTIAL
+    }
+  });
+  return {
+    bucket,
+    async get(key) {
+      try {
+        const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+        return await response.Body?.transformToByteArray();
+      } catch (error) {
+        if (isNotFound(error)) return void 0;
+        throw error;
+      }
+    },
+    async put(key, body) {
+      await client.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: body
+      }));
+    },
+    async list(prefix) {
+      const keys = [];
+      let token;
+      do {
+        const response = await client.send(new ListObjectsV2Command({
+          Bucket: bucket,
+          Prefix: prefix,
+          ContinuationToken: token
+        }));
+        for (const item of response.Contents ?? []) {
+          if (item.Key !== void 0) keys.push(item.Key);
+        }
+        token = response.IsTruncated === true ? response.NextContinuationToken : void 0;
+      } while (token !== void 0);
+      return keys;
+    }
+  };
+}
+
+// src/locator/createDappLocator.ts
+function createDappLocator(options) {
+  const logger = options.logger ?? new ConsoleLogger();
+  const bucketOptions = {
+    endpoint: options.endpoint,
+    ...options.accessKeyId !== void 0 && { accessKeyId: options.accessKeyId },
+    ...options.secretAccessKey !== void 0 && { secretAccessKey: options.secretAccessKey }
+  };
+  const instances = /* @__PURE__ */ new Map([
+    [DappDataStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: "data" })],
+    [DappStateStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: "state" })],
+    [DappIndexStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: "index" })]
+  ]);
+  return {
+    context: { logger },
+    has(moniker) {
+      return instances.has(moniker);
+    },
+    register(moniker, instance) {
+      instances.set(moniker, instance);
+    },
+    async getInstance(moniker) {
+      const found = instances.get(moniker);
+      if (found === void 0) throw new Error(`No provider registered for moniker "${moniker}"`);
+      return found;
+    },
+    async tryGetInstance(moniker) {
+      return instances.get(moniker);
+    }
+  };
+}
+
+// src/reducer/DappReducer.ts
+var noopReducer = {
+  name: "noop",
+  async reduce() {
+  }
+};
+export {
+  AbstractActor,
+  DappActor,
+  DappDataStoreMoniker,
+  DappIndexStoreMoniker,
+  DappStateStoreMoniker,
+  bootDappActors,
+  createDappLocator,
+  createS3BucketStore,
+  noopReducer
+};
+//# sourceMappingURL=index.mjs.map

package/dist/node/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/actor/AbstractActor.ts", "../../src/DappActor.ts", "../../src/providers/monikers.ts", "../../src/boot/bootDappActors.ts", "../../src/locator/createDappLocator.ts", "../../src/providers/DappBucketStore.ts", "../../src/reducer/DappReducer.ts"],
+  "sourcesContent": ["import type { CreatableInstance, Logger } from '@ariestools/sdk'\nimport {\n  AbstractCreatable, assertEx, IdLogger,\n} from '@ariestools/sdk'\n\nimport type {\n  ActorParams, DappContext, DappProviderLocator, ReadyState,\n} from './types.ts'\n\ninterface Deferred<T> {\n  promise: Promise<T>\n  reject: (reason: unknown) => void\n  resolve: (value: T) => void\n}\n\nfunction createDeferred<T>(): Deferred<T> {\n  let resolve!: (value: T) => void\n  let reject!: (reason: unknown) => void\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res\n    reject = rej\n  })\n  return {\n    promise, reject, resolve,\n  }\n}\n\n/**\n * Lean, dapp-owned fork of the xl1 `ActorV3` pattern: the create/start/stop\n * lifecycle from `AbstractCreatable`, plus non-overlapping interval timers and\n * a readiness contract. It deliberately swaps the chain's\n * `ProviderFactoryLocator`/`LocatorConfig` machinery for the small\n * {@link DappProviderLocator} seam, so a dapp actor resolves providers by\n * moniker without dragging the chain protocol config model in.\n *\n * The locator is process-wide: the daemon builds it once and passes the same\n * instance to every actor via `params.locator` (see `bootDappActors`). When\n * this graduates into a shared cli/actor toolkit \u2014 and, later, xl1-protocol \u2014\n * this base can re-adopt the real locator.\n */\nexport abstract class AbstractActor<TParams extends ActorParams = ActorParams> extends AbstractCreatable<TParams> {\n  protected readonly _intervals = new Map<string, NodeJS.Timeout>()\n  protected readonly _timeouts = new Map<string, NodeJS.Timeout>()\n\n  private _idLogger?: Logger\n  private readonly _inFlight = new Map<string, Promise<void>>()\n  private readonly _readyDeferred = createDeferred<void>()\n  private _readyError?: Error\n  private _readyState: ReadyState = 'pending'\n\n  override get logger(): Logger {\n    this._idLogger ??= new IdLogger(\n      assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`),\n      () => this.name,\n    )\n    return this._idLogger\n  }\n\n  get readyError(): Error | undefined {\n    return this._readyError\n  }\n\n  get readyState(): ReadyState {\n    return this._readyState\n  }\n\n  protected get context(): DappContext {\n    return this.locator.context\n  }\n\n  protected get locator(): DappProviderLocator {\n    return this.params.locator\n  }\n\n  static override async paramsHandler<T extends CreatableInstance>(params?: Partial<T['params']>): Promise<T['params']> {\n    const inParams = (params ?? {}) as Partial<T['params']> & { locator?: DappProviderLocator }\n    const baseParams = await super.paramsHandler({ ...inParams, name: inParams.name ?? 'UnknownActor' }) as T['params']\n    const locator = assertEx(inParams.locator, () => `params.locator is required for actor ${String(baseParams.name)}.`)\n    return { ...baseParams, locator }\n  }\n\n  /**\n   * Register a recurring task. The interval only fires while the actor is\n   * `started`, and a run is skipped if the previous one is still in flight, so\n   * a slow pass can never stack on top of itself. Must be called from\n   * `startHandler` (guards on `starting` status), mirroring the xl1 actor.\n   */\n  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number): void {\n    if (this.status !== 'starting') {\n      this.logger.warn(`Cannot register timer '${timerName}' because actor is not starting.`)\n      return\n    }\n    const tick = (): void => {\n      if (this.status !== 'started' || !this._intervals.has(timerName)) return\n      if (this._inFlight.has(timerName)) {\n        this.logger.warn(`Skipping timer '${this.name}:${timerName}' because the previous run is still in flight.`)\n        return\n      }\n      const run = (async (): Promise<void> => {\n        const startTime = Date.now()\n        try {\n          await callback()\n        } catch (error) {\n          const err = error instanceof Error ? error : new Error(String(error))\n          this.logger.error(`Error in timer '${this.name}:${timerName}': ${err.message}`)\n        } finally {\n          const duration = Date.now() - startTime\n          if (duration > periodMs) {\n            this.logger.warn(`Timer '${this.name}:${timerName}' took ${duration}ms, longer than its ${periodMs}ms period.`)\n          }\n        }\n      })()\n      this._inFlight.set(timerName, run.finally(() => {\n        this._inFlight.delete(timerName)\n      }))\n    }\n    const timeoutId = setTimeout(() => {\n      this._intervals.set(timerName, setInterval(tick, periodMs))\n    }, dueTimeMs)\n    this._timeouts.set(timerName, timeoutId)\n  }\n\n  /**\n   * Run the warm-pass once. Not driven automatically here (no orchestrator);\n   * a caller invokes it after `start()` if it wants `whenReady()` to resolve.\n   */\n  async runReadyHandler(): Promise<void> {\n    if (this._readyState !== 'pending') return\n    try {\n      await this.readyHandler()\n      this._readyState = 'ready'\n      this._readyDeferred.resolve()\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error))\n      this._readyState = 'failed'\n      this._readyError = err\n      this._readyDeferred.reject(err)\n      throw err\n    }\n  }\n\n  override async stopHandler(): Promise<void> {\n    await super.stopHandler()\n    for (const timeoutRef of this._timeouts.values()) clearTimeout(timeoutRef)\n    this._timeouts.clear()\n    for (const intervalRef of this._intervals.values()) clearInterval(intervalRef)\n    this._intervals.clear()\n    await Promise.allSettled(this._inFlight.values())\n    this._inFlight.clear()\n  }\n\n  async whenReady(): Promise<void> {\n    await this._readyDeferred.promise\n  }\n\n  /** Override to prove the actor can do useful work. Default: no-op. */\n  protected async readyHandler(): Promise<void> {\n    // no-op by default\n  }\n}\n", "import { creatable } from '@ariestools/sdk'\n\nimport { AbstractActor } from './actor/AbstractActor.ts'\nimport type { ActorParams } from './actor/types.ts'\nimport type { DappBucketStore } from './providers/DappBucketStore.ts'\nimport {\n  DappDataStoreMoniker, DappIndexStoreMoniker, DappStateStoreMoniker,\n} from './providers/monikers.ts'\nimport type { DappReducer } from './reducer/DappReducer.ts'\n\nexport interface DappActorParams extends ActorParams {\n  /** Delay before the first reduce pass. Defaults to 2000ms. */\n  firstRunDelayMs?: number\n  reduceIntervalMs?: number\n  reducer: DappReducer\n}\n\nconst DEFAULT_REDUCE_INTERVAL_MS = 5000\nconst DEFAULT_FIRST_RUN_DELAY_MS = 2000\n\n/**\n * The stock dapp actor: resolves the three bucket stores from the shared\n * locator, then drives its reducer on an interval to keep `state` and `index`\n * derived from `data`. Multiple actors (each with its own reducer) can share\n * one locator; this is the default single-reducer instance the daemon boots.\n */\n@creatable()\nexport class DappActor extends AbstractActor<DappActorParams> {\n  static readonly dependencies = [\n    DappDataStoreMoniker,\n    DappStateStoreMoniker,\n    DappIndexStoreMoniker,\n  ] as const\n\n  protected _data!: DappBucketStore\n  protected _index!: DappBucketStore\n  protected _state!: DappBucketStore\n\n  override async createHandler(): Promise<void> {\n    await super.createHandler()\n    this._data = await this.locator.getInstance<DappBucketStore>(DappDataStoreMoniker)\n    this._state = await this.locator.getInstance<DappBucketStore>(DappStateStoreMoniker)\n    this._index = await this.locator.getInstance<DappBucketStore>(DappIndexStoreMoniker)\n  }\n\n  protected override async startHandler(): Promise<void> {\n    await super.startHandler()\n    const interval = this.params.reduceIntervalMs ?? DEFAULT_REDUCE_INTERVAL_MS\n    const firstRunDelay = this.params.firstRunDelayMs ?? DEFAULT_FIRST_RUN_DELAY_MS\n    this.registerTimer('DappReduce', async () => {\n      await this.runReducePass()\n    }, firstRunDelay, interval)\n    this.logger.info(`DappActor started: reducer '${this.params.reducer.name}' every ${interval}ms`)\n  }\n\n  private async runReducePass(): Promise<void> {\n    await this.params.reducer.reduce({\n      data: this._data,\n      index: this._index,\n      logger: this.logger,\n      state: this._state,\n    })\n  }\n}\n", "/**\n * Provider monikers for the three dapp buckets. An actor declares these in its\n * `static dependencies` and resolves them from the locator at create time.\n */\nexport const DappDataStoreMoniker = 'DappDataStore' as const\nexport const DappStateStoreMoniker = 'DappStateStore' as const\nexport const DappIndexStoreMoniker = 'DappIndexStore' as const\n", "import type { CreatableName } from '@ariestools/sdk'\n\nimport type { DappProviderLocator } from '../actor/types.ts'\nimport type { DappActorParams } from '../DappActor.ts'\nimport { DappActor } from '../DappActor.ts'\nimport type { DappReducer } from '../reducer/DappReducer.ts'\n\nexport interface DappActorSpec {\n  name: string\n  reduceIntervalMs?: number\n  reducer: DappReducer\n}\n\n/**\n * Creates and starts one {@link DappActor} per spec, all sharing the single\n * process-wide locator. Returns them so the caller can stop them on shutdown.\n */\nexport async function bootDappActors(\n  locator: DappProviderLocator,\n  specs: readonly DappActorSpec[],\n): Promise<DappActor[]> {\n  const actors: DappActor[] = []\n  for (const spec of specs) {\n    const params: Partial<DappActorParams> = {\n      locator,\n      name: spec.name as CreatableName,\n      reducer: spec.reducer,\n      ...(spec.reduceIntervalMs !== undefined && { reduceIntervalMs: spec.reduceIntervalMs }),\n    }\n    const actor = await DappActor.create(params)\n    await actor.start()\n    actors.push(actor)\n  }\n  return actors\n}\n", "import type { Logger } from '@ariestools/sdk'\nimport { ConsoleLogger } from '@ariestools/sdk'\n\nimport type { DappMoniker, DappProviderLocator } from '../actor/types.ts'\nimport { createS3BucketStore } from '../providers/DappBucketStore.ts'\nimport {\n  DappDataStoreMoniker, DappIndexStoreMoniker, DappStateStoreMoniker,\n} from '../providers/monikers.ts'\n\nexport interface CreateDappLocatorOptions {\n  accessKeyId?: string\n  /** Origin the dapp server listens on, e.g. `http://127.0.0.1:8801`. */\n  endpoint: string\n  logger?: Logger\n  secretAccessKey?: string\n}\n\n/**\n * Builds the process-wide locator: one instance, shared across every actor\n * (xl1-cli style). It pre-registers an S3-backed store per bucket keyed by\n * moniker; extra providers can be `register`ed before actors are created.\n */\nexport function createDappLocator(options: CreateDappLocatorOptions): DappProviderLocator {\n  const logger = options.logger ?? new ConsoleLogger()\n  const bucketOptions = {\n    endpoint: options.endpoint,\n    ...(options.accessKeyId !== undefined && { accessKeyId: options.accessKeyId }),\n    ...(options.secretAccessKey !== undefined && { secretAccessKey: options.secretAccessKey }),\n  }\n  const instances = new Map<DappMoniker, unknown>([\n    [DappDataStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: 'data' })],\n    [DappStateStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: 'state' })],\n    [DappIndexStoreMoniker, createS3BucketStore({ ...bucketOptions, bucket: 'index' })],\n  ])\n  return {\n    context: { logger },\n    has(moniker: DappMoniker): boolean {\n      return instances.has(moniker)\n    },\n    register(moniker: DappMoniker, instance: unknown): void {\n      instances.set(moniker, instance)\n    },\n    async getInstance<T>(moniker: DappMoniker): Promise<T> {\n      const found = instances.get(moniker)\n      if (found === undefined) throw new Error(`No provider registered for moniker \"${moniker}\"`)\n      return found as T\n    },\n    async tryGetInstance<T>(moniker: DappMoniker): Promise<T | undefined> {\n      return instances.get(moniker) as T | undefined\n    },\n  }\n}\n", "import type { DappBucket } from '@ariestools/aries-dapp-serve'\nimport {\n  GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client,\n} from '@aws-sdk/client-s3'\n\n/**\n * A provider over one dapp bucket. `data` is the immutable source of truth\n * (read-only in practice); `state` and `index` are the derived buckets a\n * reducer writes. The interface is intentionally tiny \u2014 reducers compose the\n * richer read/derive/write logic on top of these primitives.\n */\nexport interface DappBucketStore {\n  readonly bucket: DappBucket\n  get(key: string): Promise<Uint8Array | undefined>\n  list(prefix?: string): Promise<string[]>\n  put(key: string, body: string | Uint8Array): Promise<void>\n}\n\nexport interface S3DappBucketStoreOptions {\n  accessKeyId?: string\n  bucket: DappBucket\n  /** Origin the dapp server listens on, e.g. `http://127.0.0.1:8801`. */\n  endpoint: string\n  secretAccessKey?: string\n}\n\nconst DEFAULT_CREDENTIAL = 'S3RVER'\n\nfunction isNotFound(error: unknown): boolean {\n  const name = (error as { name?: string }).name\n  return name === 'NoSuchKey' || name === 'NotFound'\n}\n\n/**\n * S3-backed {@link DappBucketStore} pointed at the local dapp server. Uses\n * path-style addressing so `/{bucket}/{key}` resolves as a subfolder of the\n * one origin. Under `--ssl auto` the server speaks HTTPS with a locally\n * trusted certificate; the daemon exports its CA via `NODE_EXTRA_CA_CERTS`, so\n * this client trusts it without any per-request handler configuration.\n */\nexport function createS3BucketStore(options: S3DappBucketStoreOptions): DappBucketStore {\n  const { bucket } = options\n  const client = new S3Client({\n    endpoint: options.endpoint,\n    region: 'us-east-1',\n    forcePathStyle: true,\n    credentials: {\n      accessKeyId: options.accessKeyId ?? DEFAULT_CREDENTIAL,\n      secretAccessKey: options.secretAccessKey ?? DEFAULT_CREDENTIAL,\n    },\n  })\n  return {\n    bucket,\n    async get(key: string): Promise<Uint8Array | undefined> {\n      try {\n        const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }))\n        return await response.Body?.transformToByteArray()\n      } catch (error) {\n        if (isNotFound(error)) return undefined\n        throw error\n      }\n    },\n    async put(key: string, body: string | Uint8Array): Promise<void> {\n      await client.send(new PutObjectCommand({\n        Bucket: bucket, Key: key, Body: body,\n      }))\n    },\n    async list(prefix?: string): Promise<string[]> {\n      const keys: string[] = []\n      let token: string | undefined\n      do {\n        const response = await client.send(new ListObjectsV2Command({\n          Bucket: bucket,\n          Prefix: prefix,\n          ContinuationToken: token,\n        }))\n        for (const item of response.Contents ?? []) {\n          if (item.Key !== undefined) keys.push(item.Key)\n        }\n        token = response.IsTruncated === true ? response.NextContinuationToken : undefined\n      } while (token !== undefined)\n      return keys\n    },\n  }\n}\n", "import type { Logger } from '@ariestools/sdk'\n\nimport type { DappBucketStore } from '../providers/DappBucketStore.ts'\n\n/** What a reducer is handed each pass: the three bucket stores plus a logger. */\nexport interface DappReduceContext {\n  /** Immutable source of truth. */\n  data: DappBucketStore\n  /** Derived, query-optimized views. */\n  index: DappBucketStore\n  logger: Logger\n  /** Derived current view. */\n  state: DappBucketStore\n}\n\n/**\n * The pluggable unit of dapp logic. The DappActor timer calls `reduce` on an\n * interval; an implementation reads the immutable `data` bucket and rebuilds\n * `state` and `index`. Passes should be idempotent and resume from a watermark\n * so a slow or interrupted pass is safe to repeat.\n */\nexport interface DappReducer {\n  readonly name: string\n  reduce(context: DappReduceContext): Promise<void>\n}\n\n/**\n * Default reducer: does nothing. The harness runs the full timer/provider\n * spine with this in place; supply a real reducer to derive `state` and\n * `index` from `data`.\n */\nexport const noopReducer: DappReducer = {\n  name: 'noop',\n  async reduce(): Promise<void> {\n    // no-op: the spine runs, no derivation happens\n  },\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/node/locator/createDappLocator.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '@ariestools/sdk';
+import type { DappProviderLocator } from '../actor/types.ts';
+export interface CreateDappLocatorOptions {
+    accessKeyId?: string;
+    /** Origin the dapp server listens on, e.g. `http://127.0.0.1:8801`. */
+    endpoint: string;
+    logger?: Logger;
+    secretAccessKey?: string;
+}
+/**
+ * Builds the process-wide locator: one instance, shared across every actor
+ * (xl1-cli style). It pre-registers an S3-backed store per bucket keyed by
+ * moniker; extra providers can be `register`ed before actors are created.
+ */
+export declare function createDappLocator(options: CreateDappLocatorOptions): DappProviderLocator;
+//# sourceMappingURL=createDappLocator.d.ts.map

package/dist/node/locator/createDappLocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDappLocator.d.ts","sourceRoot":"","sources":["../../../src/locator/createDappLocator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAG7C,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAMzE,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,mBAAmB,CA6BxF"}

package/dist/node/providers/DappBucketStore.d.ts

@@ -0,0 +1,29 @@
+import type { DappBucket } from '@ariestools/aries-dapp-serve';
+/**
+ * A provider over one dapp bucket. `data` is the immutable source of truth
+ * (read-only in practice); `state` and `index` are the derived buckets a
+ * reducer writes. The interface is intentionally tiny — reducers compose the
+ * richer read/derive/write logic on top of these primitives.
+ */
+export interface DappBucketStore {
+    readonly bucket: DappBucket;
+    get(key: string): Promise<Uint8Array | undefined>;
+    list(prefix?: string): Promise<string[]>;
+    put(key: string, body: string | Uint8Array): Promise<void>;
+}
+export interface S3DappBucketStoreOptions {
+    accessKeyId?: string;
+    bucket: DappBucket;
+    /** Origin the dapp server listens on, e.g. `http://127.0.0.1:8801`. */
+    endpoint: string;
+    secretAccessKey?: string;
+}
+/**
+ * S3-backed {@link DappBucketStore} pointed at the local dapp server. Uses
+ * path-style addressing so `/{bucket}/{key}` resolves as a subfolder of the
+ * one origin. Under `--ssl auto` the server speaks HTTPS with a locally
+ * trusted certificate; the daemon exports its CA via `NODE_EXTRA_CA_CERTS`, so
+ * this client trusts it without any per-request handler configuration.
+ */
+export declare function createS3BucketStore(options: S3DappBucketStoreOptions): DappBucketStore;
+//# sourceMappingURL=DappBucketStore.d.ts.map

package/dist/node/providers/DappBucketStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DappBucketStore.d.ts","sourceRoot":"","sources":["../../../src/providers/DappBucketStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAK9D;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAA;IACjD,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACxC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,UAAU,CAAA;IAClB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AASD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,GAAG,eAAe,CA4CtF"}

package/dist/node/providers/monikers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Provider monikers for the three dapp buckets. An actor declares these in its
+ * `static dependencies` and resolves them from the locator at create time.
+ */
+export declare const DappDataStoreMoniker: "DappDataStore";
+export declare const DappStateStoreMoniker: "DappStateStore";
+export declare const DappIndexStoreMoniker: "DappIndexStore";
+//# sourceMappingURL=monikers.d.ts.map

package/dist/node/providers/monikers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monikers.d.ts","sourceRoot":"","sources":["../../../src/providers/monikers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAG,eAAwB,CAAA;AAC5D,eAAO,MAAM,qBAAqB,EAAG,gBAAyB,CAAA;AAC9D,eAAO,MAAM,qBAAqB,EAAG,gBAAyB,CAAA"}

package/dist/node/reducer/DappReducer.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '@ariestools/sdk';
+import type { DappBucketStore } from '../providers/DappBucketStore.ts';
+/** What a reducer is handed each pass: the three bucket stores plus a logger. */
+export interface DappReduceContext {
+    /** Immutable source of truth. */
+    data: DappBucketStore;
+    /** Derived, query-optimized views. */
+    index: DappBucketStore;
+    logger: Logger;
+    /** Derived current view. */
+    state: DappBucketStore;
+}
+/**
+ * The pluggable unit of dapp logic. The DappActor timer calls `reduce` on an
+ * interval; an implementation reads the immutable `data` bucket and rebuilds
+ * `state` and `index`. Passes should be idempotent and resume from a watermark
+ * so a slow or interrupted pass is safe to repeat.
+ */
+export interface DappReducer {
+    readonly name: string;
+    reduce(context: DappReduceContext): Promise<void>;
+}
+/**
+ * Default reducer: does nothing. The harness runs the full timer/provider
+ * spine with this in place; supply a real reducer to derive `state` and
+ * `index` from `data`.
+ */
+export declare const noopReducer: DappReducer;
+//# sourceMappingURL=DappReducer.d.ts.map

package/dist/node/reducer/DappReducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DappReducer.d.ts","sourceRoot":"","sources":["../../../src/reducer/DappReducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE,iFAAiF;AACjF,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,sCAAsC;IACtC,KAAK,EAAE,eAAe,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,4BAA4B;IAC5B,KAAK,EAAE,eAAe,CAAA;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAClD;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,WAKzB,CAAA"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ariestools/aries-dapp-core",
+  "version": "0.1.7",
+  "description": "Aries dapp backend core: the DappActor (forked xl1 actor pattern), process-wide provider locator, pluggable reducer, and the composed daemon that runs the storage server plus actors",
+  "keywords": [
+    "ariestools",
+    "xl1",
+    "xyo",
+    "dapp",
+    "actor",
+    "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-dapp-server": "dist/bin/dappServer.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ariestools/sdk": "~8.1.1",
+    "@aws-sdk/client-s3": "~3.1090.0",
+    "tslib": "~2.8.1",
+    "@ariestools/aries-dapp-serve": "~0.1.7"
+  },
+  "devDependencies": {
+    "@ariestools/toolchain": "~8.7.16",
+    "@ariestools/tsconfig": "~8.7.16",
+    "@opentelemetry/api": "~1.9.1",
+    "@types/node": "~26.1.1",
+    "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"
+  }
+}