@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/sdk-utils/neutral/integrations.mjs

@@ -0,0 +1,3 @@
+// src/integrations.ts
+export * from "../../metamask-connector/browser/index.mjs";
+export * from "../../quadkey/neutral/index.mjs";

package/dist/_pkg/sdk-utils/neutral/plugins.d.ts

@@ -0,0 +1 @@
+export * from '../../payload-plugin/neutral/index.ts';

package/dist/_pkg/sdk-utils/neutral/plugins.mjs

@@ -0,0 +1,2 @@
+// src/plugins.ts
+export * from "../../payload-plugin/neutral/index.mjs";

package/dist/_pkg/sdk-utils/neutral/validation.d.ts

@@ -0,0 +1 @@
+export * from '../../schema-cache/neutral/index.ts';

package/dist/_pkg/sdk-utils/neutral/validation.mjs

@@ -0,0 +1,2 @@
+// src/validation.ts
+export * from "../../schema-cache/neutral/index.mjs";

package/dist/_pkg/sentinel/neutral/abstract.d.ts

@@ -0,0 +1 @@
+export * from '../../sentinel-abstract/neutral/index.ts';

package/dist/_pkg/sentinel/neutral/abstract.mjs

@@ -0,0 +1,2 @@
+// src/abstract.ts
+export * from "../../sentinel-abstract/neutral/index.mjs";

package/dist/_pkg/sentinel/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../../sentinel-abstract/neutral/index.ts';
+export * from '../../sentinel-memory/neutral/index.ts';
+export * from '../../sentinel-model/neutral/index.ts';
+export * from '../../sentinel-wrapper/neutral/index.ts';

package/dist/_pkg/sentinel/neutral/index.mjs

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../sentinel-abstract/neutral/index.mjs";
+export * from "../../sentinel-memory/neutral/index.mjs";
+export * from "../../sentinel-model/neutral/index.mjs";
+export * from "../../sentinel-wrapper/neutral/index.mjs";

package/dist/_pkg/sentinel/neutral/model.d.ts

@@ -0,0 +1 @@
+export * from '../../sentinel-model/neutral/index.ts';

package/dist/_pkg/sentinel/neutral/model.mjs

@@ -0,0 +1,2 @@
+// src/model.ts
+export * from "../../sentinel-model/neutral/index.mjs";

package/dist/_pkg/sentinel/neutral/wrapper.d.ts

@@ -0,0 +1 @@
+export * from '../../sentinel-wrapper/neutral/index.ts';

package/dist/_pkg/sentinel/neutral/wrapper.mjs

@@ -0,0 +1,2 @@
+// src/wrapper.ts
+export * from "../../sentinel-wrapper/neutral/index.mjs";

package/dist/_pkg/sentinel-abstract/neutral/AbstractSentinel.d.ts

@@ -0,0 +1,21 @@
+import { AbstractModuleInstance } from '../../module-abstract/neutral/index.ts';
+import type { ModuleConfig, ModuleQueryHandlerResult, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, BoundWitness, Payload, QueryBoundWitness, Schema } from '../../sdk-protocol/neutral/index.ts';
+import type { AttachableSentinelInstance, CustomSentinelInstance, SentinelInstance, SentinelJob, SentinelModuleEventData, SentinelParams } from '../../sentinel-model/neutral/index.ts';
+export declare abstract class AbstractSentinel<TParams extends SentinelParams = SentinelParams, TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>> extends AbstractModuleInstance<TParams, TEventData> implements CustomSentinelInstance<TParams, TEventData>, AttachableSentinelInstance<TParams, TEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly uniqueName: string;
+    history: BoundWitness[];
+    private _jobPromise?;
+    get jobPromise(): Promise<SentinelJob>;
+    get queries(): Schema[];
+    get synchronous(): boolean;
+    get throwErrors(): boolean;
+    report(inPayloads?: Payload[]): Promise<Payload[]>;
+    reportQuery(payloads?: Payload[], account?: AccountInstance): Promise<ModuleQueryResult>;
+    protected emitReportEnd(inPayloads?: Payload[], payloads?: Payload[]): Promise<void>;
+    protected generateJob(): Promise<SentinelJob>;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads?: Payload[], queryConfig?: TConfig): Promise<ModuleQueryHandlerResult>;
+    abstract reportHandler(payloads?: Payload[]): Promise<Payload[]>;
+}

package/dist/_pkg/sentinel-abstract/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './AbstractSentinel.ts';

package/dist/_pkg/sentinel-abstract/neutral/index.mjs

@@ -0,0 +1,143 @@
+// src/AbstractSentinel.ts
+import {
+  assertEx,
+  forget,
+  globallyUnique
+} from "@xylabs/sdk";
+import { AbstractModuleInstance } from "../../module-abstract/neutral/index.mjs";
+import {
+  BoundWitnessBuilder,
+  isBoundWitness,
+  PayloadBuilder,
+  QueryBoundWitnessWrapper
+} from "../../sdk-protocol/neutral/index.mjs";
+import {
+  SentinelConfigSchema,
+  SentinelReportQuerySchema
+} from "../../sentinel-model/neutral/index.mjs";
+var AbstractSentinel = class _AbstractSentinel extends AbstractModuleInstance {
+  static configSchemas = [...super.configSchemas, SentinelConfigSchema];
+  static defaultConfigSchema = SentinelConfigSchema;
+  static uniqueName = globallyUnique("AbstractSentinel", _AbstractSentinel, "xyo");
+  history = [];
+  _jobPromise;
+  get jobPromise() {
+    this._jobPromise = this._jobPromise ?? this.generateJob();
+    return this._jobPromise;
+  }
+  get queries() {
+    return [SentinelReportQuerySchema, ...super.queries];
+  }
+  get synchronous() {
+    return this.config.synchronous ?? true;
+  }
+  get throwErrors() {
+    return this.config.throwErrors ?? true;
+  }
+  async report(inPayloads) {
+    this._noOverride("report");
+    this.isSupportedQuery(SentinelReportQuerySchema, "report");
+    return await this.spanAsync("report", async () => {
+      const reportPromise = (async () => {
+        if (this.reentrancy?.scope === "global" && this.reentrancy?.action === "skip" && this.globalReentrancyMutex?.isLocked()) {
+          console.warn(`Skipping report for ${this.id} due to global reentrancy lock`);
+          return [];
+        }
+        try {
+          await this.globalReentrancyMutex?.acquire();
+          await this.emit("reportStart", { inPayloads, mod: this });
+          const payloads = await this.reportHandler(inPayloads);
+          const result = (await new BoundWitnessBuilder().payloads(payloads).signer(this.account).build()).flat();
+          if (this.config.archiving) {
+            forget(this.storeToArchivists(result), { name: `AbstractSentinel.report.storeArchivist [${this.id}]` });
+          }
+          await this.emitReportEnd(inPayloads, result);
+          return result;
+        } finally {
+          this.globalReentrancyMutex?.release();
+        }
+      })();
+      if (this.synchronous) {
+        return await reportPromise;
+      } else {
+        forget(reportPromise, { name: `AbstractSentinel.report [${this.id}]` });
+        return [];
+      }
+    }, { timeBudgetLimit: 200 });
+  }
+  async reportQuery(payloads, account) {
+    this._noOverride("reportQuery");
+    const queryPayload = { schema: SentinelReportQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+  async emitReportEnd(inPayloads, payloads) {
+    const boundwitnesses = payloads?.filter(isBoundWitness) ?? [];
+    const outPayloads = payloads?.filter((payload) => !isBoundWitness(payload)) ?? [];
+    const boundwitness = boundwitnesses.find((bw) => bw.addresses.includes(this.address));
+    await this.emit("reportEnd", {
+      boundwitness,
+      inPayloads,
+      mod: this,
+      outPayloads
+    });
+  }
+  async generateJob() {
+    const job = { tasks: [] };
+    let tasks = await Promise.all(
+      (this.config.tasks ?? []).map(async (task) => ({
+        input: task.input ?? false,
+        mod: assertEx(await this.resolve(task.mod), () => `Unable to resolve task module [${task.mod}]`)
+      }))
+    );
+    while (tasks.length > 0) {
+      const previousTasks = job.tasks.at(-1) ?? [];
+      const newListCandidates = tasks.filter((task) => {
+        const input = task.input;
+        if (input === void 0) {
+          return true;
+        }
+        if (typeof input === "boolean") {
+          return true;
+        }
+        if (typeof input === "string") {
+          return previousTasks.some((prevTask) => prevTask.mod.address === input || prevTask.mod.modName === input);
+        }
+        if (Array.isArray(input)) {
+          return previousTasks.some(
+            (prevTask) => input.includes(prevTask.mod.address) || input.includes(prevTask.mod.modName ?? prevTask.mod.address)
+          );
+        }
+        return false;
+      });
+      const newList = newListCandidates.filter((taskCandidate) => {
+        const input = taskCandidate.input;
+        return !(Array.isArray(input) && tasks.some(
+          (remainingTask) => input.includes(remainingTask.mod.address) || input.includes(remainingTask.mod.modName ?? remainingTask.mod.address)
+        ));
+      });
+      assertEx(newList.length > 0, () => `Unable to generateJob [${tasks.length}]`);
+      job.tasks.push(newList);
+      tasks = tasks.filter((task) => !newList.includes(task));
+    }
+    return job;
+  }
+  async queryHandler(query, payloads, queryConfig) {
+    const wrapper = QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    assertEx(await this.queryable(query, payloads, queryConfig));
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case SentinelReportQuerySchema: {
+        resultPayloads.push(...await this.report(payloads));
+        break;
+      }
+      default: {
+        return super.queryHandler(query, payloads);
+      }
+    }
+    return PayloadBuilder.omitPrivateStorageMeta(resultPayloads);
+  }
+};
+export {
+  AbstractSentinel
+};

package/dist/_pkg/sentinel-memory/neutral/MemorySentinel.d.ts

@@ -0,0 +1,16 @@
+import { type AnyConfigSchema } from '../../module-model/neutral/index.ts';
+import type { Payload, Schema } from '../../sdk-protocol/neutral/index.ts';
+import { AbstractSentinel } from '../../sentinel-abstract/neutral/index.ts';
+import type { SentinelConfig, SentinelInstance, SentinelModuleEventData, SentinelParams } from '../../sentinel-model/neutral/index.ts';
+export type MemorySentinelParams<TConfig extends AnyConfigSchema<SentinelConfig> = AnyConfigSchema<SentinelConfig>> = SentinelParams<TConfig>;
+export declare class MemorySentinel<TParams extends MemorySentinelParams = MemorySentinelParams, TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>> extends AbstractSentinel<TParams, TEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    private runner?;
+    reportHandler(inPayloads?: Payload[]): Promise<Payload[]>;
+    startHandler(): Promise<void>;
+    stopHandler(): Promise<void>;
+    private inputAddresses;
+    private processPreviousResults;
+    private runJob;
+}

package/dist/_pkg/sentinel-memory/neutral/SentinelIntervalAutomationWrapper.d.ts

@@ -0,0 +1,20 @@
+import { PayloadWrapper } from '../../sdk-protocol/neutral/index.ts';
+import type { SentinelIntervalAutomationPayload } from '../../sentinel-model/neutral/index.ts';
+export declare class SentinelIntervalAutomationWrapper<T extends SentinelIntervalAutomationPayload = SentinelIntervalAutomationPayload> extends PayloadWrapper<T> {
+    constructor(payload: T);
+    protected get frequencyMillis(): number;
+    protected get remaining(): number;
+    next(): this;
+    protected checkEnd(): void;
+    protected consumeRemaining(count?: number): void;
+    /**
+     * Sets the remaining of the wrapped automation
+     * @param remaining The remaining time in milliseconds
+     */
+    protected setRemaining(remaining: number): void;
+    /**
+     * Sets the start of the wrapped automation
+     * @param start The start time in milliseconds
+     */
+    protected setStart(start: number): void;
+}

package/dist/_pkg/sentinel-memory/neutral/SentinelRunner.d.ts

@@ -0,0 +1,29 @@
+import type { BaseParams, BrandedHash } from '@xylabs/sdk';
+import { Base } from '@xylabs/sdk';
+import type { Payload } from '../../sdk-protocol/neutral/index.ts';
+import type { SentinelAutomationPayload, SentinelInstance } from '../../sentinel-model/neutral/index.ts';
+export type OnSentinelRunnerTriggerResult = (result: Payload[]) => void;
+export interface SentinelRunnerParams extends BaseParams {
+    automations?: SentinelAutomationPayload[];
+    onTriggerResult?: OnSentinelRunnerTriggerResult;
+    sentinel: SentinelInstance;
+}
+export declare class SentinelRunner extends Base {
+    protected _automations: Record<string, SentinelAutomationPayload>;
+    protected onTriggerResult: OnSentinelRunnerTriggerResult | undefined;
+    protected sentinel: SentinelInstance;
+    protected timeoutId?: ReturnType<typeof setTimeout> | string | number;
+    constructor(params: SentinelRunnerParams);
+    get automations(): Record<string, SentinelAutomationPayload>;
+    private get next();
+    add(automation: SentinelAutomationPayload, restart?: boolean): Promise<BrandedHash>;
+    find(hash: string): [string, SentinelAutomationPayload] | undefined;
+    remove(hash: string, restart?: boolean): void;
+    removeAll(): void;
+    restart(): void;
+    start(): void;
+    startHandler(): void;
+    stop(): void;
+    update(hash: string, automation: SentinelAutomationPayload, restart?: boolean): Promise<void>;
+    private trigger;
+}

package/dist/_pkg/sentinel-memory/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MemorySentinel.ts';
+export * from './SentinelIntervalAutomationWrapper.ts';
+export * from './SentinelRunner.ts';

package/dist/_pkg/sentinel-memory/neutral/index.mjs

@@ -0,0 +1,324 @@
+// src/MemorySentinel.ts
+import { fulfilled, rejected } from "@xylabs/sdk";
+import { asDivinerInstance } from "../../diviner-model/neutral/index.mjs";
+import { AbstractSentinel } from "../../sentinel-abstract/neutral/index.mjs";
+import {
+  asSentinelInstance,
+  SentinelConfigSchema
+} from "../../sentinel-model/neutral/index.mjs";
+import { asWitnessInstance } from "../../witness-model/neutral/index.mjs";
+
+// src/SentinelRunner.ts
+import {
+  assertEx,
+  Base,
+  forget,
+  isDefined,
+  spanRootAsync
+} from "@xylabs/sdk";
+import { PayloadBuilder } from "../../sdk-protocol/neutral/index.mjs";
+import { isSentinelIntervalAutomation } from "../../sentinel-model/neutral/index.mjs";
+
+// src/SentinelIntervalAutomationWrapper.ts
+import { PayloadWrapper } from "../../sdk-protocol/neutral/index.mjs";
+var SentinelIntervalAutomationWrapper = class extends PayloadWrapper {
+  constructor(payload) {
+    super(payload);
+  }
+  get frequencyMillis() {
+    const frequency = this.payload.frequency;
+    if (frequency === void 0) return Number.POSITIVE_INFINITY;
+    const frequencyUnits = this.payload.frequencyUnits;
+    switch (frequencyUnits ?? "hour") {
+      case "millis": {
+        return frequency;
+      }
+      case "second": {
+        return frequency * 1e3;
+      }
+      case "minute": {
+        return frequency * 60 * 1e3;
+      }
+      case "hour": {
+        return frequency * 60 * 60 * 1e3;
+      }
+      case "day": {
+        return frequency * 24 * 60 * 60 * 1e3;
+      }
+      default: {
+        return Number.POSITIVE_INFINITY;
+      }
+    }
+  }
+  get remaining() {
+    return this.payload.remaining ?? Number.POSITIVE_INFINITY;
+  }
+  next() {
+    const now = Date.now();
+    const previousStart = this.payload?.start ?? now;
+    const start = Math.max(previousStart, now);
+    const nextStart = start + this.frequencyMillis;
+    this.setStart(nextStart);
+    this.consumeRemaining();
+    this.checkEnd();
+    return this;
+  }
+  checkEnd() {
+    if ((this.payload.start ?? 0) > (this.payload.end ?? Number.POSITIVE_INFINITY)) {
+      this.setStart(Number.POSITIVE_INFINITY);
+    }
+  }
+  consumeRemaining(count = 1) {
+    const remaining = Math.max(this.remaining - count, 0);
+    this.setRemaining(remaining);
+    if (remaining <= 0) this.setStart(Number.POSITIVE_INFINITY);
+  }
+  /**
+   * Sets the remaining of the wrapped automation
+   * @param remaining The remaining time in milliseconds
+   */
+  setRemaining(remaining) {
+    this.payload.remaining = remaining;
+  }
+  /**
+   * Sets the start of the wrapped automation
+   * @param start The start time in milliseconds
+   */
+  setStart(start) {
+    this.payload.start = start;
+  }
+};
+
+// src/SentinelRunner.ts
+var SentinelRunner = class extends Base {
+  _automations = {};
+  onTriggerResult;
+  sentinel;
+  timeoutId;
+  constructor(params) {
+    super(params);
+    this.sentinel = params.sentinel;
+    this.onTriggerResult = params.onTriggerResult;
+    if (params.automations) for (const automation of params.automations) forget(this.add(automation));
+  }
+  get automations() {
+    return this._automations;
+  }
+  get next() {
+    return Object.values(this._automations).reduce((previous, current) => {
+      if (isSentinelIntervalAutomation(current) && isSentinelIntervalAutomation(previous)) {
+        return (current.start ?? Number.POSITIVE_INFINITY) < (previous?.start ?? Number.POSITIVE_INFINITY) ? current : previous;
+      }
+      return current;
+    }, void 0);
+  }
+  async add(automation, restart = true) {
+    const hash = await PayloadBuilder.dataHash(automation);
+    this._automations[hash] = automation;
+    if (restart) this.restart();
+    return hash;
+  }
+  find(hash) {
+    return Object.entries(this._automations).find(([key]) => key === hash);
+  }
+  remove(hash, restart = true) {
+    delete this._automations[hash];
+    if (restart) this.restart();
+  }
+  removeAll() {
+    this.stop();
+    this._automations = {};
+  }
+  restart() {
+    this.stop();
+    this.start();
+  }
+  start() {
+    this.startHandler();
+  }
+  startHandler() {
+    assertEx(this.timeoutId === void 0, () => "Already started");
+    const automation = this.next;
+    if (isSentinelIntervalAutomation(automation)) {
+      const now = Date.now();
+      const start = Math.max(automation.start ?? now, now);
+      const delay = Math.max(start - now, 0);
+      if (delay < Number.POSITIVE_INFINITY) {
+        this.timeoutId = setTimeout(async () => {
+          this.timeoutId = void 0;
+          return await spanRootAsync("start.setTimeout", async () => {
+            try {
+              await this.trigger(automation);
+              this.stop();
+            } catch (ex) {
+              this.logger?.error("Error running automation", { error: ex });
+              this.stop();
+            } finally {
+              this.start();
+            }
+          }, { tracer: this.tracer });
+        }, delay);
+      }
+    }
+  }
+  stop() {
+    if (isDefined(this.timeoutId)) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = void 0;
+    }
+  }
+  async update(hash, automation, restart = true) {
+    this.remove(hash, false);
+    await this.add(automation, false);
+    if (restart) this.restart();
+  }
+  async trigger(automation) {
+    return await spanRootAsync("trigger", async () => {
+      const wrapper = new SentinelIntervalAutomationWrapper(automation);
+      this.remove(await wrapper.dataHash(), false);
+      wrapper.next();
+      await this.add(wrapper.payload, false);
+      const triggerResult = await this.sentinel.report();
+      this.onTriggerResult?.(triggerResult);
+    }, { tracer: this.tracer });
+  }
+};
+
+// src/MemorySentinel.ts
+var MemorySentinel = class extends AbstractSentinel {
+  static configSchemas = [...super.configSchemas, SentinelConfigSchema];
+  static defaultConfigSchema = SentinelConfigSchema;
+  runner;
+  async reportHandler(inPayloads = []) {
+    await this.startedAsync("throw");
+    this.logger?.debug(`reportHandler:in: ${JSON.stringify(inPayloads)}`);
+    const job = await this.jobPromise;
+    let index = 0;
+    let previousResults = {};
+    while (index < job.tasks.length) {
+      const generatedPayloads = await this.runJob(job.tasks[index], previousResults, inPayloads);
+      previousResults = generatedPayloads;
+      index++;
+    }
+    const result = Object.values(previousResults).flat();
+    this.logger?.debug(`reportHandler:out: ${JSON.stringify(result)}`);
+    return result;
+  }
+  async startHandler() {
+    await super.startHandler();
+    if ((this.config.automations?.length ?? 0) > 0) {
+      this.runner = new SentinelRunner({
+        sentinel: this,
+        automations: this.config.automations,
+        traceProvider: this.params.traceProvider
+      });
+      this.runner.start();
+    }
+  }
+  async stopHandler() {
+    if (this.runner) {
+      this.runner.stop();
+      this.runner = void 0;
+    }
+    await super.stopHandler();
+  }
+  async inputAddresses(input) {
+    if (Array.isArray(input)) {
+      return (await Promise.all(input.map(async (inputItem) => await this.inputAddresses(inputItem)))).flat();
+    } else {
+      const resolved = await this.resolve(input);
+      return resolved ? [resolved.address] : [];
+    }
+  }
+  processPreviousResults(payloads, inputs) {
+    return inputs.flatMap((input) => payloads[input] ?? []);
+  }
+  async runJob(tasks, previousResults, inPayloads) {
+    await this.emit("jobStart", { inPayloads, mod: this });
+    this.logger?.debug(`runJob:tasks: ${JSON.stringify(tasks.length)}`);
+    this.logger?.debug(`runJob:previous: ${JSON.stringify(previousResults)}`);
+    this.logger?.debug(`runJob:in: ${JSON.stringify(inPayloads)}`);
+    const results = await Promise.allSettled(
+      tasks?.map(async (task) => {
+        const input = task.input ?? false;
+        const inPayloadsFound = input === true ? inPayloads : input === false ? [] : this.processPreviousResults(previousResults, await this.inputAddresses(input));
+        const witness = asWitnessInstance(task.mod);
+        if (witness) {
+          await this.emit("taskStart", {
+            address: witness.address,
+            inPayloads: inPayloadsFound,
+            mod: this
+          });
+          const observed = await witness.observe(inPayloadsFound);
+          this.logger?.debug(`observed [${witness.id}]: ${JSON.stringify(observed)}`);
+          await this.emit("taskEnd", {
+            address: witness.address,
+            inPayloads: inPayloadsFound,
+            mod: this,
+            outPayloads: observed
+          });
+          return [witness.address, observed];
+        }
+        const diviner = asDivinerInstance(task.mod);
+        if (diviner) {
+          await this.emit("taskStart", {
+            address: diviner.address,
+            inPayloads: inPayloadsFound,
+            mod: this
+          });
+          const divined = await diviner.divine(inPayloadsFound);
+          this.logger?.debug(`divined [${diviner.id}]: ${JSON.stringify(divined)}`);
+          await this.emit("taskEnd", {
+            address: diviner.address,
+            inPayloads: inPayloadsFound,
+            mod: this,
+            outPayloads: divined
+          });
+          return [diviner.address, divined];
+        }
+        const sentinel = asSentinelInstance(task.mod);
+        if (sentinel) {
+          await this.emit("taskStart", {
+            address: sentinel.address,
+            inPayloads: inPayloadsFound,
+            mod: this
+          });
+          const reported = await sentinel.report(inPayloadsFound);
+          this.logger?.debug(`reported [${sentinel.id}]: ${JSON.stringify(reported)}`);
+          await this.emit("taskEnd", {
+            address: sentinel.address,
+            inPayloads: inPayloadsFound,
+            mod: this,
+            outPayloads: reported
+          });
+          return [sentinel.address, reported];
+        }
+        throw new Error("Unsupported module type");
+      })
+    );
+    const finalResult = {};
+    for (const result of results.filter(fulfilled)) {
+      const [address, payloads] = result.value;
+      finalResult[address] = finalResult[address] ?? [];
+      finalResult[address].push(...payloads);
+    }
+    if (this.throwErrors) {
+      const errors = results.filter(rejected).map((result) => result.reason);
+      if (errors.length > 0) {
+        throw new Error("At least one module failed");
+      }
+    }
+    this.logger?.debug(`generateResults:out: ${JSON.stringify(finalResult)}`);
+    await this.emit("jobEnd", {
+      finalResult,
+      inPayloads,
+      mod: this
+    });
+    return finalResult;
+  }
+};
+export {
+  MemorySentinel,
+  SentinelIntervalAutomationWrapper,
+  SentinelRunner
+};

package/dist/_pkg/sentinel-model/neutral/Automation.d.ts

@@ -0,0 +1,47 @@
+import type { EventName } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../module-model/neutral/index.ts';
+import type { Payload } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const SentinelAutomationSchema: 'network.xyo.automation' & {
+    readonly __schema: true;
+};
+export type SentinelAutomationSchema = typeof SentinelAutomationSchema;
+export declare const SentinelIntervalAutomationSchema: 'network.xyo.automation.interval' & {
+    readonly __schema: true;
+};
+export type SentinelIntervalAutomationSchema = typeof SentinelIntervalAutomationSchema;
+export declare const SentinelModuleEventAutomationSchema: 'network.xyo.automation.event.module' & {
+    readonly __schema: true;
+};
+export type SentinelModuleEventAutomationSchema = typeof SentinelModuleEventAutomationSchema;
+export type SentinelBaseAutomationPayload<T extends Payload> = Payload<{
+    type?: 'interval' | 'event';
+} & T>;
+/** Settings for an Interval Automation */
+export declare const SentinelIntervalAutomationZod: z.ZodMiniObject<{
+    end: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    frequency: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    frequencyUnits: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<'second'>, z.ZodMiniLiteral<'minute'>, z.ZodMiniLiteral<'hour'>, z.ZodMiniLiteral<'day'>, z.ZodMiniLiteral<'millis'>]>>;
+    remaining: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    schema: z.ZodMiniLiteral<SentinelIntervalAutomationSchema>;
+    start: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    type: z.ZodMiniLiteral<'interval'>;
+}, z.core.$strip>;
+export type SentinelIntervalAutomationPayload = z.infer<typeof SentinelIntervalAutomationZod>;
+export declare const isSentinelIntervalAutomation: ReturnType<typeof zodIsFactory<SentinelIntervalAutomationPayload>>;
+export declare const asSentinelIntervalAutomation: ReturnType<typeof zodAsFactory<SentinelIntervalAutomationPayload>>;
+export declare const toSentinelIntervalAutomation: ReturnType<typeof zodToFactory<SentinelIntervalAutomationPayload>>;
+/** Settings for an Module Event Automation */
+export declare const SentinelModuleEventAutomationZod: z.ZodMiniObject<{
+    eventName: z.ZodMiniCustom<EventName, EventName>;
+    schema: z.ZodMiniLiteral<SentinelModuleEventAutomationSchema>;
+    source: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+    type: z.ZodMiniLiteral<'event'>;
+}, z.core.$strip>;
+export type SentinelModuleEventAutomationPayload = z.infer<typeof SentinelModuleEventAutomationZod>;
+export declare const isSentinelModuleEventAutomation: ReturnType<typeof zodIsFactory<SentinelModuleEventAutomationPayload>>;
+export declare const asSentinelModuleEventAutomation: ReturnType<typeof zodAsFactory<SentinelModuleEventAutomationPayload>>;
+export declare const toSentinelModuleEventAutomation: ReturnType<typeof zodToFactory<SentinelModuleEventAutomationPayload>>;
+/** Settings for an Automation */
+export type SentinelAutomationPayload = Payload<SentinelIntervalAutomationPayload | SentinelModuleEventAutomationPayload, SentinelAutomationSchema | SentinelIntervalAutomationSchema | SentinelModuleEventAutomationSchema>;