@xyo-network/sdk 7.0.9 → 7.0.10

package/dist/neutral/sentinel-memory.mjs

@@ -0,0 +1,325 @@
+// src/modules/sentinel-memory/MemorySentinel.ts
+import { fulfilled, rejected } from "@ariestools/sdk";
+import { asDivinerInstance } from "#diviner-model";
+import { AbstractSentinel } from "#sentinel-abstract";
+import {
+  asSentinelInstance,
+  SentinelConfigSchema
+} from "#sentinel-model";
+import { asWitnessInstance } from "#witness-model";
+
+// src/modules/sentinel-memory/SentinelRunner.ts
+import {
+  assertEx,
+  Base,
+  forget,
+  isDefined,
+  spanRootAsync
+} from "@ariestools/sdk";
+import { PayloadBuilder } from "@xyo-network/sdk-protocol";
+import { isSentinelIntervalAutomation } from "#sentinel-model";
+
+// src/modules/sentinel-memory/SentinelIntervalAutomationWrapper.ts
+import { PayloadWrapper } from "@xyo-network/sdk-protocol";
+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/modules/sentinel-memory/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/modules/sentinel-memory/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
+};
+//# sourceMappingURL=sentinel-memory.mjs.map

package/dist/neutral/sentinel-memory.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/sentinel-memory/MemorySentinel.ts", "../../src/modules/sentinel-memory/SentinelRunner.ts", "../../src/modules/sentinel-memory/SentinelIntervalAutomationWrapper.ts"],
+  "sourcesContent": ["import { fulfilled, rejected } from '@ariestools/sdk'\nimport type {\n  Payload, Schema, XyoAddress,\n} from '@xyo-network/sdk-protocol'\n\nimport { asDivinerInstance } from '#diviner-model'\nimport { type AnyConfigSchema, type ModuleIdentifier } from '#module-model'\nimport { AbstractSentinel } from '#sentinel-abstract'\nimport type {\n  ResolvedTask,\n  SentinelConfig,\n  SentinelInstance,\n  SentinelModuleEventData,\n  SentinelParams,\n} from '#sentinel-model'\nimport {\n  asSentinelInstance,\n  SentinelConfigSchema,\n} from '#sentinel-model'\nimport { asWitnessInstance } from '#witness-model'\n\nimport { SentinelRunner } from './SentinelRunner.ts'\n\nexport type MemorySentinelParams<TConfig extends AnyConfigSchema<SentinelConfig> = AnyConfigSchema<SentinelConfig>> = SentinelParams<TConfig>\n\nexport class MemorySentinel<\n  TParams extends MemorySentinelParams = MemorySentinelParams,\n  TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>,\n> extends AbstractSentinel<TParams, TEventData> {\n  static override readonly configSchemas: Schema[] = [...super.configSchemas, SentinelConfigSchema]\n  static override readonly defaultConfigSchema: Schema = SentinelConfigSchema\n\n  private runner?: SentinelRunner\n\n  async reportHandler(inPayloads: Payload[] = []): Promise<Payload[]> {\n    await this.startedAsync('throw')\n    this.logger?.debug(`reportHandler:in: ${JSON.stringify(inPayloads)}`)\n    const job = await this.jobPromise\n\n    let index = 0\n    let previousResults: Record<XyoAddress, Payload[]> = {}\n    while (index < job.tasks.length) {\n      const generatedPayloads = await this.runJob(job.tasks[index], previousResults, inPayloads)\n      previousResults = generatedPayloads\n      index++\n    }\n    const result = Object.values(previousResults).flat()\n    this.logger?.debug(`reportHandler:out: ${JSON.stringify(result)}`)\n    return result\n  }\n\n  override async startHandler(): Promise<void> {\n    await super.startHandler()\n    if ((this.config.automations?.length ?? 0) > 0) {\n      this.runner = new SentinelRunner({\n        sentinel: this, automations: this.config.automations, traceProvider: this.params.traceProvider,\n      })\n      this.runner.start()\n    }\n  }\n\n  override async stopHandler(): Promise<void> {\n    if (this.runner) {\n      this.runner.stop()\n      this.runner = undefined\n    }\n    await super.stopHandler()\n  }\n\n  private async inputAddresses(input: ModuleIdentifier | ModuleIdentifier[]): Promise<XyoAddress[]> {\n    if (Array.isArray(input)) {\n      return (await Promise.all(input.map(async inputItem => await this.inputAddresses(inputItem)))).flat()\n    } else {\n      const resolved = await this.resolve(input)\n      return resolved ? [resolved.address] : []\n    }\n  }\n\n  private processPreviousResults(payloads: Record<string, Payload[]>, inputs: string[]) {\n    return inputs.flatMap(input => payloads[input] ?? [])\n  }\n\n  private async runJob(\n    tasks: ResolvedTask[],\n    previousResults: Record<XyoAddress, Payload[]>,\n    inPayloads?: Payload[],\n  ): Promise<Record<XyoAddress, Payload[]>> {\n    await this.emit('jobStart', { inPayloads, mod: this })\n    this.logger?.debug(`runJob:tasks: ${JSON.stringify(tasks.length)}`)\n    this.logger?.debug(`runJob:previous: ${JSON.stringify(previousResults)}`)\n    this.logger?.debug(`runJob:in: ${JSON.stringify(inPayloads)}`)\n    const results: PromiseSettledResult<[XyoAddress, Payload[]]>[] = await Promise.allSettled(\n      tasks?.map(async (task) => {\n        const input = task.input ?? false\n        const inPayloadsFound\n          = input === true\n            ? inPayloads\n            : input === false\n              ? []\n              : this.processPreviousResults(previousResults, await this.inputAddresses(input))\n        const witness = asWitnessInstance(task.mod)\n        if (witness) {\n          await this.emit('taskStart', {\n            address: witness.address, inPayloads: inPayloadsFound, mod: this,\n          })\n          const observed = await witness.observe(inPayloadsFound)\n          this.logger?.debug(`observed [${witness.id}]: ${JSON.stringify(observed)}`)\n          await this.emit('taskEnd', {\n            address: witness.address, inPayloads: inPayloadsFound, mod: this, outPayloads: observed,\n          })\n          return [witness.address, observed]\n        }\n        const diviner = asDivinerInstance(task.mod)\n        if (diviner) {\n          await this.emit('taskStart', {\n            address: diviner.address, inPayloads: inPayloadsFound, mod: this,\n          })\n          const divined = await diviner.divine(inPayloadsFound)\n          this.logger?.debug(`divined [${diviner.id}]: ${JSON.stringify(divined)}`)\n          await this.emit('taskEnd', {\n            address: diviner.address, inPayloads: inPayloadsFound, mod: this, outPayloads: divined,\n          })\n          return [diviner.address, divined]\n        }\n        const sentinel = asSentinelInstance(task.mod)\n        if (sentinel) {\n          await this.emit('taskStart', {\n            address: sentinel.address, inPayloads: inPayloadsFound, mod: this,\n          })\n          const reported = await sentinel.report(inPayloadsFound)\n          this.logger?.debug(`reported [${sentinel.id}]: ${JSON.stringify(reported)}`)\n          await this.emit('taskEnd', {\n            address: sentinel.address, inPayloads: inPayloadsFound, mod: this, outPayloads: reported,\n          })\n          return [sentinel.address, reported]\n        }\n        throw new Error('Unsupported module type')\n      }),\n    )\n    const finalResult: Record<XyoAddress, Payload[]> = {}\n    for (const result of results.filter(fulfilled)) {\n      const [address, payloads] = result.value\n      finalResult[address] = finalResult[address] ?? []\n      finalResult[address].push(...payloads)\n    }\n    if (this.throwErrors) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      const errors = results.filter(rejected).map(result => result.reason)\n      if (errors.length > 0) {\n        throw new Error('At least one module failed')\n      }\n    }\n    this.logger?.debug(`generateResults:out: ${JSON.stringify(finalResult)}`)\n    await this.emit('jobEnd', {\n      finalResult, inPayloads, mod: this,\n    })\n    return finalResult\n  }\n}\n", "import type { BaseParams, BrandedHash } from '@ariestools/sdk'\nimport {\n  assertEx, Base, forget,\n  isDefined, spanRootAsync,\n} from '@ariestools/sdk'\nimport type { Payload } from '@xyo-network/sdk-protocol'\nimport { PayloadBuilder } from '@xyo-network/sdk-protocol'\n\nimport type {\n  SentinelAutomationPayload,\n  SentinelInstance,\n  SentinelIntervalAutomationPayload,\n} from '#sentinel-model'\nimport { isSentinelIntervalAutomation } from '#sentinel-model'\n\nimport { SentinelIntervalAutomationWrapper } from './SentinelIntervalAutomationWrapper.ts'\n\nexport type OnSentinelRunnerTriggerResult = (result: Payload[]) => void\n\nexport interface SentinelRunnerParams extends BaseParams {\n  automations?: SentinelAutomationPayload[]\n  onTriggerResult?: OnSentinelRunnerTriggerResult\n  sentinel: SentinelInstance\n}\n\nexport class SentinelRunner extends Base {\n  protected _automations: Record<string, SentinelAutomationPayload> = {}\n  protected onTriggerResult: OnSentinelRunnerTriggerResult | undefined\n  protected sentinel: SentinelInstance\n  protected timeoutId?: ReturnType<typeof setTimeout> | string | number\n\n  constructor(params: SentinelRunnerParams) {\n    super(params)\n    this.sentinel = params.sentinel\n    this.onTriggerResult = params.onTriggerResult\n\n    if (params.automations) for (const automation of params.automations) forget(this.add(automation))\n  }\n\n  get automations(): Record<string, SentinelAutomationPayload> {\n    return this._automations\n  }\n\n  private get next() {\n    return Object.values(this._automations).reduce<SentinelAutomationPayload | undefined>((previous, current) => {\n      if (isSentinelIntervalAutomation(current) && isSentinelIntervalAutomation(previous)) {\n        return (current.start ?? Number.POSITIVE_INFINITY) < (previous?.start ?? Number.POSITIVE_INFINITY) ? current : previous\n      }\n      return current\n    }, undefined)\n  }\n\n  async add(automation: SentinelAutomationPayload, restart = true): Promise<BrandedHash> {\n    const hash = await PayloadBuilder.dataHash(automation)\n    this._automations[hash] = automation\n    if (restart) this.restart()\n    return hash\n  }\n\n  find(hash: string): [string, SentinelAutomationPayload] | undefined {\n    return Object.entries(this._automations).find(([key]) => key === hash)\n  }\n\n  remove(hash: string, restart = true): void {\n    delete this._automations[hash]\n    if (restart) this.restart()\n  }\n\n  removeAll(): void {\n    this.stop()\n    this._automations = {}\n  }\n\n  restart(): void {\n    this.stop()\n    this.start()\n  }\n\n  start(): void {\n    this.startHandler()\n  }\n\n  startHandler(): void {\n    assertEx(this.timeoutId === undefined, () => 'Already started')\n    const automation = this.next\n    if (isSentinelIntervalAutomation(automation)) {\n      const now = Date.now()\n      const start = Math.max(automation.start ?? now, now)\n      const delay = Math.max(start - now, 0)\n      if (delay < Number.POSITIVE_INFINITY) {\n        // eslint-disable-next-line @typescript-eslint/no-misused-promises\n        this.timeoutId = setTimeout(async () => {\n          this.timeoutId = undefined\n          return await spanRootAsync('start.setTimeout', async () => {\n            try {\n            // Run the automation\n              await this.trigger(automation)\n              this.stop()\n            } catch (ex) {\n              this.logger?.error('Error running automation', { error: ex })\n              this.stop()\n            } finally {\n              // No matter what start the next automation\n              this.start()\n            }\n          }, { tracer: this.tracer })\n        }, delay)\n      }\n    }\n  }\n\n  stop(): void {\n    if (isDefined(this.timeoutId)) {\n      clearTimeout(this.timeoutId)\n      this.timeoutId = undefined\n    }\n  }\n\n  async update(hash: string, automation: SentinelAutomationPayload, restart = true): Promise<void> {\n    this.remove(hash, false)\n    await this.add(automation, false)\n    if (restart) this.restart()\n  }\n\n  private async trigger(automation: SentinelIntervalAutomationPayload) {\n    return await spanRootAsync('trigger', async () => {\n      const wrapper = new SentinelIntervalAutomationWrapper(automation)\n      this.remove(await wrapper.dataHash(), false)\n      wrapper.next()\n      await this.add(wrapper.payload, false)\n      const triggerResult = await this.sentinel.report()\n      this.onTriggerResult?.(triggerResult)\n    }, { tracer: this.tracer })\n  }\n}\n", "import { PayloadWrapper } from '@xyo-network/sdk-protocol'\n\nimport type { SentinelIntervalAutomationPayload } from '#sentinel-model'\n\nexport class SentinelIntervalAutomationWrapper<\n  T extends SentinelIntervalAutomationPayload = SentinelIntervalAutomationPayload,\n> extends PayloadWrapper<T> {\n  constructor(payload: T) {\n    super(payload)\n  }\n\n  protected get frequencyMillis(): number {\n    const frequency = this.payload.frequency\n    if (frequency === undefined) return Number.POSITIVE_INFINITY\n    const frequencyUnits = this.payload.frequencyUnits\n    switch (frequencyUnits ?? 'hour') {\n      case 'millis': {\n        return frequency\n      }\n      case 'second': {\n        return frequency * 1000\n      }\n      case 'minute': {\n        return frequency * 60 * 1000\n      }\n      case 'hour': {\n        return frequency * 60 * 60 * 1000\n      }\n      case 'day': {\n        return frequency * 24 * 60 * 60 * 1000\n      }\n      default: {\n        return Number.POSITIVE_INFINITY\n      }\n    }\n  }\n\n  protected get remaining(): number {\n    return this.payload.remaining ?? Number.POSITIVE_INFINITY\n  }\n\n  next(): this {\n    const now = Date.now()\n    const previousStart = this.payload?.start ?? now\n    const start = Math.max(previousStart, now)\n    const nextStart = start + this.frequencyMillis\n    this.setStart(nextStart)\n    this.consumeRemaining()\n    this.checkEnd()\n    return this\n  }\n\n  protected checkEnd(): void {\n    if ((this.payload.start ?? 0) > (this.payload.end ?? Number.POSITIVE_INFINITY)) {\n      this.setStart(Number.POSITIVE_INFINITY)\n    }\n  }\n\n  protected consumeRemaining(count = 1): void {\n    const remaining = Math.max(this.remaining - count, 0)\n    this.setRemaining(remaining)\n    if (remaining <= 0) this.setStart(Number.POSITIVE_INFINITY)\n  }\n\n  /**\n   * Sets the remaining of the wrapped automation\n   * @param remaining The remaining time in milliseconds\n   */\n  protected setRemaining(remaining: number): void {\n    this.payload.remaining = remaining\n  }\n\n  /**\n   * Sets the start of the wrapped automation\n   * @param start The start time in milliseconds\n   */\n  protected setStart(start: number): void {\n    this.payload.start = start\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,WAAW,gBAAgB;AAKpC,SAAS,yBAAyB;AAElC,SAAS,wBAAwB;AAQjC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;;;AClBlC;AAAA,EACE;AAAA,EAAU;AAAA,EAAM;AAAA,EAChB;AAAA,EAAW;AAAA,OACN;AAEP,SAAS,sBAAsB;AAO/B,SAAS,oCAAoC;;;ACb7C,SAAS,sBAAsB;AAIxB,IAAM,oCAAN,cAEG,eAAkB;AAAA,EAC1B,YAAY,SAAY;AACtB,UAAM,OAAO;AAAA,EACf;AAAA,EAEA,IAAc,kBAA0B;AACtC,UAAM,YAAY,KAAK,QAAQ;AAC/B,QAAI,cAAc,OAAW,QAAO,OAAO;AAC3C,UAAM,iBAAiB,KAAK,QAAQ;AACpC,YAAQ,kBAAkB,QAAQ;AAAA,MAChC,KAAK,UAAU;AACb,eAAO;AAAA,MACT;AAAA,MACA,KAAK,UAAU;AACb,eAAO,YAAY;AAAA,MACrB;AAAA,MACA,KAAK,UAAU;AACb,eAAO,YAAY,KAAK;AAAA,MAC1B;AAAA,MACA,KAAK,QAAQ;AACX,eAAO,YAAY,KAAK,KAAK;AAAA,MAC/B;AAAA,MACA,KAAK,OAAO;AACV,eAAO,YAAY,KAAK,KAAK,KAAK;AAAA,MACpC;AAAA,MACA,SAAS;AACP,eAAO,OAAO;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IAAc,YAAoB;AAChC,WAAO,KAAK,QAAQ,aAAa,OAAO;AAAA,EAC1C;AAAA,EAEA,OAAa;AACX,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,gBAAgB,KAAK,SAAS,SAAS;AAC7C,UAAM,QAAQ,KAAK,IAAI,eAAe,GAAG;AACzC,UAAM,YAAY,QAAQ,KAAK;AAC/B,SAAK,SAAS,SAAS;AACvB,SAAK,iBAAiB;AACtB,SAAK,SAAS;AACd,WAAO;AAAA,EACT;AAAA,EAEU,WAAiB;AACzB,SAAK,KAAK,QAAQ,SAAS,MAAM,KAAK,QAAQ,OAAO,OAAO,oBAAoB;AAC9E,WAAK,SAAS,OAAO,iBAAiB;AAAA,IACxC;AAAA,EACF;AAAA,EAEU,iBAAiB,QAAQ,GAAS;AAC1C,UAAM,YAAY,KAAK,IAAI,KAAK,YAAY,OAAO,CAAC;AACpD,SAAK,aAAa,SAAS;AAC3B,QAAI,aAAa,EAAG,MAAK,SAAS,OAAO,iBAAiB;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMU,aAAa,WAAyB;AAC9C,SAAK,QAAQ,YAAY;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMU,SAAS,OAAqB;AACtC,SAAK,QAAQ,QAAQ;AAAA,EACvB;AACF;;;ADtDO,IAAM,iBAAN,cAA6B,KAAK;AAAA,EAC7B,eAA0D,CAAC;AAAA,EAC3D;AAAA,EACA;AAAA,EACA;AAAA,EAEV,YAAY,QAA8B;AACxC,UAAM,MAAM;AACZ,SAAK,WAAW,OAAO;AACvB,SAAK,kBAAkB,OAAO;AAE9B,QAAI,OAAO,YAAa,YAAW,cAAc,OAAO,YAAa,QAAO,KAAK,IAAI,UAAU,CAAC;AAAA,EAClG;AAAA,EAEA,IAAI,cAAyD;AAC3D,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAY,OAAO;AACjB,WAAO,OAAO,OAAO,KAAK,YAAY,EAAE,OAA8C,CAAC,UAAU,YAAY;AAC3G,UAAI,6BAA6B,OAAO,KAAK,6BAA6B,QAAQ,GAAG;AACnF,gBAAQ,QAAQ,SAAS,OAAO,sBAAsB,UAAU,SAAS,OAAO,qBAAqB,UAAU;AAAA,MACjH;AACA,aAAO;AAAA,IACT,GAAG,MAAS;AAAA,EACd;AAAA,EAEA,MAAM,IAAI,YAAuC,UAAU,MAA4B;AACrF,UAAM,OAAO,MAAM,eAAe,SAAS,UAAU;AACrD,SAAK,aAAa,IAAI,IAAI;AAC1B,QAAI,QAAS,MAAK,QAAQ;AAC1B,WAAO;AAAA,EACT;AAAA,EAEA,KAAK,MAA+D;AAClE,WAAO,OAAO,QAAQ,KAAK,YAAY,EAAE,KAAK,CAAC,CAAC,GAAG,MAAM,QAAQ,IAAI;AAAA,EACvE;AAAA,EAEA,OAAO,MAAc,UAAU,MAAY;AACzC,WAAO,KAAK,aAAa,IAAI;AAC7B,QAAI,QAAS,MAAK,QAAQ;AAAA,EAC5B;AAAA,EAEA,YAAkB;AAChB,SAAK,KAAK;AACV,SAAK,eAAe,CAAC;AAAA,EACvB;AAAA,EAEA,UAAgB;AACd,SAAK,KAAK;AACV,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,QAAc;AACZ,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,eAAqB;AACnB,aAAS,KAAK,cAAc,QAAW,MAAM,iBAAiB;AAC9D,UAAM,aAAa,KAAK;AACxB,QAAI,6BAA6B,UAAU,GAAG;AAC5C,YAAM,MAAM,KAAK,IAAI;AACrB,YAAM,QAAQ,KAAK,IAAI,WAAW,SAAS,KAAK,GAAG;AACnD,YAAM,QAAQ,KAAK,IAAI,QAAQ,KAAK,CAAC;AACrC,UAAI,QAAQ,OAAO,mBAAmB;AAEpC,aAAK,YAAY,WAAW,YAAY;AACtC,eAAK,YAAY;AACjB,iBAAO,MAAM,cAAc,oBAAoB,YAAY;AACzD,gBAAI;AAEF,oBAAM,KAAK,QAAQ,UAAU;AAC7B,mBAAK,KAAK;AAAA,YACZ,SAAS,IAAI;AACX,mBAAK,QAAQ,MAAM,4BAA4B,EAAE,OAAO,GAAG,CAAC;AAC5D,mBAAK,KAAK;AAAA,YACZ,UAAE;AAEA,mBAAK,MAAM;AAAA,YACb;AAAA,UACF,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC;AAAA,QAC5B,GAAG,KAAK;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAa;AACX,QAAI,UAAU,KAAK,SAAS,GAAG;AAC7B,mBAAa,KAAK,SAAS;AAC3B,WAAK,YAAY;AAAA,IACnB;AAAA,EACF;AAAA,EAEA,MAAM,OAAO,MAAc,YAAuC,UAAU,MAAqB;AAC/F,SAAK,OAAO,MAAM,KAAK;AACvB,UAAM,KAAK,IAAI,YAAY,KAAK;AAChC,QAAI,QAAS,MAAK,QAAQ;AAAA,EAC5B;AAAA,EAEA,MAAc,QAAQ,YAA+C;AACnE,WAAO,MAAM,cAAc,WAAW,YAAY;AAChD,YAAM,UAAU,IAAI,kCAAkC,UAAU;AAChE,WAAK,OAAO,MAAM,QAAQ,SAAS,GAAG,KAAK;AAC3C,cAAQ,KAAK;AACb,YAAM,KAAK,IAAI,QAAQ,SAAS,KAAK;AACrC,YAAM,gBAAgB,MAAM,KAAK,SAAS,OAAO;AACjD,WAAK,kBAAkB,aAAa;AAAA,IACtC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC;AAAA,EAC5B;AACF;;;AD7GO,IAAM,iBAAN,cAGG,iBAAsC;AAAA,EAC9C,OAAyB,gBAA0B,CAAC,GAAG,MAAM,eAAe,oBAAoB;AAAA,EAChG,OAAyB,sBAA8B;AAAA,EAE/C;AAAA,EAER,MAAM,cAAc,aAAwB,CAAC,GAAuB;AAClE,UAAM,KAAK,aAAa,OAAO;AAC/B,SAAK,QAAQ,MAAM,qBAAqB,KAAK,UAAU,UAAU,CAAC,EAAE;AACpE,UAAM,MAAM,MAAM,KAAK;AAEvB,QAAI,QAAQ;AACZ,QAAI,kBAAiD,CAAC;AACtD,WAAO,QAAQ,IAAI,MAAM,QAAQ;AAC/B,YAAM,oBAAoB,MAAM,KAAK,OAAO,IAAI,MAAM,KAAK,GAAG,iBAAiB,UAAU;AACzF,wBAAkB;AAClB;AAAA,IACF;AACA,UAAM,SAAS,OAAO,OAAO,eAAe,EAAE,KAAK;AACnD,SAAK,QAAQ,MAAM,sBAAsB,KAAK,UAAU,MAAM,CAAC,EAAE;AACjE,WAAO;AAAA,EACT;AAAA,EAEA,MAAe,eAA8B;AAC3C,UAAM,MAAM,aAAa;AACzB,SAAK,KAAK,OAAO,aAAa,UAAU,KAAK,GAAG;AAC9C,WAAK,SAAS,IAAI,eAAe;AAAA,QAC/B,UAAU;AAAA,QAAM,aAAa,KAAK,OAAO;AAAA,QAAa,eAAe,KAAK,OAAO;AAAA,MACnF,CAAC;AACD,WAAK,OAAO,MAAM;AAAA,IACpB;AAAA,EACF;AAAA,EAEA,MAAe,cAA6B;AAC1C,QAAI,KAAK,QAAQ;AACf,WAAK,OAAO,KAAK;AACjB,WAAK,SAAS;AAAA,IAChB;AACA,UAAM,MAAM,YAAY;AAAA,EAC1B;AAAA,EAEA,MAAc,eAAe,OAAqE;AAChG,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,cAAQ,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAM,cAAa,MAAM,KAAK,eAAe,SAAS,CAAC,CAAC,GAAG,KAAK;AAAA,IACtG,OAAO;AACL,YAAM,WAAW,MAAM,KAAK,QAAQ,KAAK;AACzC,aAAO,WAAW,CAAC,SAAS,OAAO,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AAAA,EAEQ,uBAAuB,UAAqC,QAAkB;AACpF,WAAO,OAAO,QAAQ,WAAS,SAAS,KAAK,KAAK,CAAC,CAAC;AAAA,EACtD;AAAA,EAEA,MAAc,OACZ,OACA,iBACA,YACwC;AACxC,UAAM,KAAK,KAAK,YAAY,EAAE,YAAY,KAAK,KAAK,CAAC;AACrD,SAAK,QAAQ,MAAM,iBAAiB,KAAK,UAAU,MAAM,MAAM,CAAC,EAAE;AAClE,SAAK,QAAQ,MAAM,oBAAoB,KAAK,UAAU,eAAe,CAAC,EAAE;AACxE,SAAK,QAAQ,MAAM,cAAc,KAAK,UAAU,UAAU,CAAC,EAAE;AAC7D,UAAM,UAA2D,MAAM,QAAQ;AAAA,MAC7E,OAAO,IAAI,OAAO,SAAS;AACzB,cAAM,QAAQ,KAAK,SAAS;AAC5B,cAAM,kBACF,UAAU,OACR,aACA,UAAU,QACR,CAAC,IACD,KAAK,uBAAuB,iBAAiB,MAAM,KAAK,eAAe,KAAK,CAAC;AACrF,cAAM,UAAU,kBAAkB,KAAK,GAAG;AAC1C,YAAI,SAAS;AACX,gBAAM,KAAK,KAAK,aAAa;AAAA,YAC3B,SAAS,QAAQ;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,UAC9D,CAAC;AACD,gBAAM,WAAW,MAAM,QAAQ,QAAQ,eAAe;AACtD,eAAK,QAAQ,MAAM,aAAa,QAAQ,EAAE,MAAM,KAAK,UAAU,QAAQ,CAAC,EAAE;AAC1E,gBAAM,KAAK,KAAK,WAAW;AAAA,YACzB,SAAS,QAAQ;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,YAAM,aAAa;AAAA,UACjF,CAAC;AACD,iBAAO,CAAC,QAAQ,SAAS,QAAQ;AAAA,QACnC;AACA,cAAM,UAAU,kBAAkB,KAAK,GAAG;AAC1C,YAAI,SAAS;AACX,gBAAM,KAAK,KAAK,aAAa;AAAA,YAC3B,SAAS,QAAQ;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,UAC9D,CAAC;AACD,gBAAM,UAAU,MAAM,QAAQ,OAAO,eAAe;AACpD,eAAK,QAAQ,MAAM,YAAY,QAAQ,EAAE,MAAM,KAAK,UAAU,OAAO,CAAC,EAAE;AACxE,gBAAM,KAAK,KAAK,WAAW;AAAA,YACzB,SAAS,QAAQ;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,YAAM,aAAa;AAAA,UACjF,CAAC;AACD,iBAAO,CAAC,QAAQ,SAAS,OAAO;AAAA,QAClC;AACA,cAAM,WAAW,mBAAmB,KAAK,GAAG;AAC5C,YAAI,UAAU;AACZ,gBAAM,KAAK,KAAK,aAAa;AAAA,YAC3B,SAAS,SAAS;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,UAC/D,CAAC;AACD,gBAAM,WAAW,MAAM,SAAS,OAAO,eAAe;AACtD,eAAK,QAAQ,MAAM,aAAa,SAAS,EAAE,MAAM,KAAK,UAAU,QAAQ,CAAC,EAAE;AAC3E,gBAAM,KAAK,KAAK,WAAW;AAAA,YACzB,SAAS,SAAS;AAAA,YAAS,YAAY;AAAA,YAAiB,KAAK;AAAA,YAAM,aAAa;AAAA,UAClF,CAAC;AACD,iBAAO,CAAC,SAAS,SAAS,QAAQ;AAAA,QACpC;AACA,cAAM,IAAI,MAAM,yBAAyB;AAAA,MAC3C,CAAC;AAAA,IACH;AACA,UAAM,cAA6C,CAAC;AACpD,eAAW,UAAU,QAAQ,OAAO,SAAS,GAAG;AAC9C,YAAM,CAAC,SAAS,QAAQ,IAAI,OAAO;AACnC,kBAAY,OAAO,IAAI,YAAY,OAAO,KAAK,CAAC;AAChD,kBAAY,OAAO,EAAE,KAAK,GAAG,QAAQ;AAAA,IACvC;AACA,QAAI,KAAK,aAAa;AAEpB,YAAM,SAAS,QAAQ,OAAO,QAAQ,EAAE,IAAI,YAAU,OAAO,MAAM;AACnE,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAC9C;AAAA,IACF;AACA,SAAK,QAAQ,MAAM,wBAAwB,KAAK,UAAU,WAAW,CAAC,EAAE;AACxE,UAAM,KAAK,KAAK,UAAU;AAAA,MACxB;AAAA,MAAa;AAAA,MAAY,KAAK;AAAA,IAChC,CAAC;AACD,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,2 @@
+export * from './modules/sentinel-model/index.js';
+//# sourceMappingURL=sentinel-model.d.ts.map

package/dist/neutral/sentinel-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentinel-model.d.ts","sourceRoot":"","sources":["../../src/sentinel-model.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA"}

package/dist/neutral/sentinel-model.mjs

@@ -0,0 +1,151 @@
+// src/modules/sentinel-model/attachable/asAttachableInstance.ts
+import { AsObjectFactory as AsObjectFactory2 } from "@ariestools/sdk";
+
+// src/modules/sentinel-model/attachable/isAttachableInstance.ts
+import { IsObjectFactory } from "@ariestools/sdk";
+import { isAttachableModuleInstance } from "#module-model";
+
+// src/modules/sentinel-model/typeChecks.ts
+import { AsObjectFactory } from "@ariestools/sdk";
+import {
+  IsInstanceFactory,
+  isModuleInstance,
+  IsQueryableModuleFactory,
+  WithFactory
+} from "#module-model";
+
+// src/modules/sentinel-model/Queries/Report.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@ariestools/sdk";
+import {
+  asSchema,
+  PayloadZodOfSchema,
+  QueryFieldsZod
+} from "@xyo-network/sdk-protocol";
+import * as z from "zod/mini";
+var SentinelReportQuerySchema = asSchema("network.xyo.query.sentinel.report", true);
+var SentinelReportQueryZod = z.extend(PayloadZodOfSchema(SentinelReportQuerySchema), { ...QueryFieldsZod.shape });
+var isSentinelReportQuery = zodIsFactory(SentinelReportQueryZod);
+var asSentinelReportQuery = zodAsFactory(SentinelReportQueryZod, "asSentinelReportQuery");
+var toSentinelReportQuery = zodToFactory(SentinelReportQueryZod, "toSentinelReportQuery");
+
+// src/modules/sentinel-model/typeChecks.ts
+var isSentinelInstance = new IsInstanceFactory().create({ report: "function" }, [isModuleInstance]);
+var isSentinelModule = new IsQueryableModuleFactory().create([SentinelReportQuerySchema]);
+var asSentinelModule = AsObjectFactory.create(isSentinelModule);
+var asSentinelInstance = AsObjectFactory.create(isSentinelInstance);
+var withSentinelModule = WithFactory.create(isSentinelModule);
+var withSentinelInstance = WithFactory.create(isSentinelInstance);
+
+// src/modules/sentinel-model/attachable/isAttachableInstance.ts
+var requiredAttachableSentinelInstanceFunctions = {};
+var factory = new IsObjectFactory();
+var isAttachableSentinelInstance = factory.create(requiredAttachableSentinelInstanceFunctions, [
+  isSentinelInstance,
+  isAttachableModuleInstance
+]);
+
+// src/modules/sentinel-model/attachable/asAttachableInstance.ts
+var asAttachableSentinelInstance = AsObjectFactory2.create(isAttachableSentinelInstance);
+
+// src/modules/sentinel-model/attachable/AttachableInstance.ts
+import { IsObjectFactory as IsObjectFactory2 } from "@ariestools/sdk";
+var IsAttachableSentinelInstanceFactory = class extends IsObjectFactory2 {
+};
+
+// src/modules/sentinel-model/Automation.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk-protocol";
+import * as z2 from "zod/mini";
+var SentinelAutomationSchema = asSchema2("network.xyo.automation", true);
+var SentinelIntervalAutomationSchema = asSchema2("network.xyo.automation.interval", true);
+var SentinelModuleEventAutomationSchema = asSchema2("network.xyo.automation.event.module", true);
+var SentinelIntervalAutomationZod = z2.extend(PayloadZodOfSchema2(SentinelIntervalAutomationSchema), {
+  /** Epoch after which any reoccurrence stops */
+  end: z2.optional(z2.number()),
+  /** Time between triggers [non-repeating if undefined] */
+  frequency: z2.optional(z2.number()),
+  /** Units for frequency field [hour if undefined] */
+  frequencyUnits: z2.optional(z2.union([z2.literal("second"), z2.literal("minute"), z2.literal("hour"), z2.literal("day"), z2.literal("millis")])),
+  /** Remaining triggers [infinite if undefined] */
+  remaining: z2.optional(z2.number()),
+  /** Epoch of the next trigger */
+  start: z2.optional(z2.number()),
+  /** The type of automation */
+  type: z2.literal("interval")
+});
+var isSentinelIntervalAutomation = zodIsFactory2(SentinelIntervalAutomationZod);
+var asSentinelIntervalAutomation = zodAsFactory2(SentinelIntervalAutomationZod, "asSentinelIntervalAutomation");
+var toSentinelIntervalAutomation = zodToFactory2(SentinelIntervalAutomationZod, "toSentinelIntervalAutomation");
+var SentinelModuleEventAutomationZod = z2.extend(PayloadZodOfSchema2(SentinelModuleEventAutomationSchema), {
+  eventName: z2.custom(),
+  source: z2.custom(),
+  type: z2.literal("event")
+});
+var isSentinelModuleEventAutomation = zodIsFactory2(SentinelModuleEventAutomationZod);
+var asSentinelModuleEventAutomation = zodAsFactory2(SentinelModuleEventAutomationZod, "asSentinelModuleEventAutomation");
+var toSentinelModuleEventAutomation = zodToFactory2(SentinelModuleEventAutomationZod, "toSentinelModuleEventAutomation");
+
+// src/modules/sentinel-model/Config.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema3
+} from "@xyo-network/sdk-protocol";
+import * as z3 from "zod/mini";
+import { ModuleConfigZod } from "#module-model";
+var SentinelConfigSchema = asSchema3("network.xyo.sentinel.config", true);
+var SentinelConfigZod = z3.extend(ModuleConfigZod, {
+  schema: z3.literal(SentinelConfigSchema),
+  automations: z3.optional(z3.array(z3.custom())),
+  synchronous: z3.optional(z3.boolean()),
+  tasks: z3.array(z3.custom()),
+  throwErrors: z3.optional(z3.boolean())
+});
+var isSentinelConfig = zodIsFactory3(SentinelConfigZod);
+var asSentinelConfig = zodAsFactory3(SentinelConfigZod, "asSentinelConfig");
+var toSentinelConfig = zodToFactory3(SentinelConfigZod, "toSentinelConfig");
+export {
+  IsAttachableSentinelInstanceFactory,
+  SentinelAutomationSchema,
+  SentinelConfigSchema,
+  SentinelConfigZod,
+  SentinelIntervalAutomationSchema,
+  SentinelIntervalAutomationZod,
+  SentinelModuleEventAutomationSchema,
+  SentinelModuleEventAutomationZod,
+  SentinelReportQuerySchema,
+  SentinelReportQueryZod,
+  asAttachableSentinelInstance,
+  asSentinelConfig,
+  asSentinelInstance,
+  asSentinelIntervalAutomation,
+  asSentinelModule,
+  asSentinelModuleEventAutomation,
+  asSentinelReportQuery,
+  isAttachableSentinelInstance,
+  isSentinelConfig,
+  isSentinelInstance,
+  isSentinelIntervalAutomation,
+  isSentinelModule,
+  isSentinelModuleEventAutomation,
+  isSentinelReportQuery,
+  requiredAttachableSentinelInstanceFunctions,
+  toSentinelConfig,
+  toSentinelIntervalAutomation,
+  toSentinelModuleEventAutomation,
+  toSentinelReportQuery,
+  withSentinelInstance,
+  withSentinelModule
+};
+//# sourceMappingURL=sentinel-model.mjs.map

package/dist/neutral/sentinel-model.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/sentinel-model/attachable/asAttachableInstance.ts", "../../src/modules/sentinel-model/attachable/isAttachableInstance.ts", "../../src/modules/sentinel-model/typeChecks.ts", "../../src/modules/sentinel-model/Queries/Report.ts", "../../src/modules/sentinel-model/attachable/AttachableInstance.ts", "../../src/modules/sentinel-model/Automation.ts", "../../src/modules/sentinel-model/Config.ts"],
+  "sourcesContent": ["import { AsObjectFactory } from '@ariestools/sdk'\n\nimport { isAttachableSentinelInstance } from './isAttachableInstance.ts'\n\nexport const asAttachableSentinelInstance = AsObjectFactory.create(isAttachableSentinelInstance)\n", "import type { ObjectTypeShape, TypeCheck } from '@ariestools/sdk'\nimport { IsObjectFactory } from '@ariestools/sdk'\n\nimport { isAttachableModuleInstance } from '#module-model'\n\nimport { isSentinelInstance } from '../typeChecks.ts'\nimport type { AttachableSentinelInstance } from './AttachableInstance.ts'\n\nexport const requiredAttachableSentinelInstanceFunctions: ObjectTypeShape = {}\n\n// we do not use IsInstanceFactory here to prevent a cycle\nconst factory = new IsObjectFactory<AttachableSentinelInstance>()\n\nexport const isAttachableSentinelInstance: TypeCheck<AttachableSentinelInstance> = factory.create(requiredAttachableSentinelInstanceFunctions, [\n  isSentinelInstance,\n  isAttachableModuleInstance,\n])\n", "import { AsObjectFactory } from '@ariestools/sdk'\n\nimport {\n  IsInstanceFactory, isModuleInstance, IsQueryableModuleFactory, WithFactory,\n} from '#module-model'\n\nimport type { SentinelInstance } from './Instance.ts'\nimport type { SentinelModule } from './Module.ts'\nimport { SentinelReportQuerySchema } from './Queries/index.ts'\n\nexport const isSentinelInstance = new IsInstanceFactory<SentinelInstance>().create({ report: 'function' }, [isModuleInstance])\nexport const isSentinelModule = new IsQueryableModuleFactory<SentinelModule>().create([SentinelReportQuerySchema])\n\nexport const asSentinelModule = AsObjectFactory.create(isSentinelModule)\nexport const asSentinelInstance = AsObjectFactory.create(isSentinelInstance)\n\n/** @deprecated use narrowing instead [ if(is) ] */\n// eslint-disable-next-line @typescript-eslint/no-deprecated\nexport const withSentinelModule = WithFactory.create(isSentinelModule)\n/** @deprecated use narrowing instead [ if(is) ] */\n// eslint-disable-next-line @typescript-eslint/no-deprecated\nexport const withSentinelInstance = WithFactory.create(isSentinelInstance)\n", "import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport {\n  asSchema, PayloadZodOfSchema, QueryFieldsZod,\n} from '@xyo-network/sdk-protocol'\nimport * as z from 'zod/mini'\n\nexport const SentinelReportQuerySchema: 'network.xyo.query.sentinel.report' & {\n  readonly __schema: true\n} = asSchema('network.xyo.query.sentinel.report', true)\nexport type SentinelReportQuerySchema = typeof SentinelReportQuerySchema\n\nexport const SentinelReportQueryZod: z.ZodMiniObject<\n  & { schema: z.ZodMiniLiteral<SentinelReportQuerySchema> }\n  & (typeof QueryFieldsZod)['shape'],\n  z.core.$strip\n> = z.extend(PayloadZodOfSchema(SentinelReportQuerySchema), { ...QueryFieldsZod.shape })\n\nexport type SentinelReportQuery = z.infer<typeof SentinelReportQueryZod>\n\nexport const isSentinelReportQuery: ReturnType<typeof zodIsFactory<SentinelReportQuery>> = zodIsFactory(SentinelReportQueryZod)\nexport const asSentinelReportQuery: ReturnType<typeof zodAsFactory<SentinelReportQuery>> = zodAsFactory(SentinelReportQueryZod, 'asSentinelReportQuery')\nexport const toSentinelReportQuery: ReturnType<typeof zodToFactory<SentinelReportQuery>> = zodToFactory(SentinelReportQueryZod, 'toSentinelReportQuery')\n", "import type { TypeCheck } from '@ariestools/sdk'\nimport { IsObjectFactory } from '@ariestools/sdk'\n\nimport type { AttachableModuleInstance } from '#module-model'\n\nimport type { SentinelModuleEventData } from '../EventData.ts'\nimport type { SentinelInstance } from '../Instance.ts'\nimport type { SentinelModule } from '../Module.ts'\nimport type { SentinelParams } from '../Params.ts'\n\nexport interface AttachableSentinelInstance<\n  TParams extends SentinelParams = SentinelParams,\n  TEventData extends SentinelModuleEventData = SentinelModuleEventData,\n> extends SentinelModule<TParams, TEventData>,\n  AttachableModuleInstance<TParams, TEventData>,\n  SentinelInstance<TParams, TEventData> {}\n\nexport type AttachableSentinelInstanceTypeCheck<T extends AttachableSentinelInstance = AttachableSentinelInstance> = TypeCheck<T>\n\nexport class IsAttachableSentinelInstanceFactory<T extends AttachableSentinelInstance = AttachableSentinelInstance> extends IsObjectFactory<T> {}\n", "import type { EventName } from '@ariestools/sdk'\nimport {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport type { Payload } from '@xyo-network/sdk-protocol'\nimport { asSchema, PayloadZodOfSchema } from '@xyo-network/sdk-protocol'\nimport * as z from 'zod/mini'\n\nimport type { ModuleIdentifier } from '#module-model'\n\nexport const SentinelAutomationSchema: 'network.xyo.automation' & {\n  readonly __schema: true\n} = asSchema('network.xyo.automation', true)\nexport type SentinelAutomationSchema = typeof SentinelAutomationSchema\n\nexport const SentinelIntervalAutomationSchema: 'network.xyo.automation.interval' & {\n  readonly __schema: true\n} = asSchema('network.xyo.automation.interval', true)\nexport type SentinelIntervalAutomationSchema = typeof SentinelIntervalAutomationSchema\n\nexport const SentinelModuleEventAutomationSchema: 'network.xyo.automation.event.module' & {\n  readonly __schema: true\n} = asSchema('network.xyo.automation.event.module', true)\nexport type SentinelModuleEventAutomationSchema = typeof SentinelModuleEventAutomationSchema\n\nexport type SentinelBaseAutomationPayload<T extends Payload> = Payload<\n  {\n    type?: 'interval' | 'event'\n  } & T\n>\n\n/** Settings for an Interval Automation */\nexport const SentinelIntervalAutomationZod: z.ZodMiniObject<{\n  end: z.ZodMiniOptional<z.ZodMiniNumber<number>>\n  frequency: z.ZodMiniOptional<z.ZodMiniNumber<number>>\n  frequencyUnits: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<'second'>, z.ZodMiniLiteral<'minute'>, z.ZodMiniLiteral<'hour'>, z.ZodMiniLiteral<'day'>, z.ZodMiniLiteral<'millis'>]>>\n  remaining: z.ZodMiniOptional<z.ZodMiniNumber<number>>\n  schema: z.ZodMiniLiteral<SentinelIntervalAutomationSchema>\n  start: z.ZodMiniOptional<z.ZodMiniNumber<number>>\n  type: z.ZodMiniLiteral<'interval'>\n}, z.core.$strip> = z.extend(PayloadZodOfSchema(SentinelIntervalAutomationSchema), {\n  /** Epoch after which any reoccurrence stops */\n  end: z.optional(z.number()),\n  /** Time between triggers [non-repeating if undefined] */\n  frequency: z.optional(z.number()),\n  /** Units for frequency field [hour if undefined] */\n  frequencyUnits: z.optional(z.union([z.literal('second'), z.literal('minute'), z.literal('hour'), z.literal('day'), z.literal('millis')])),\n  /** Remaining triggers [infinite if undefined] */\n  remaining: z.optional(z.number()),\n  /** Epoch of the next trigger */\n  start: z.optional(z.number()),\n  /** The type of automation */\n  type: z.literal('interval'),\n})\n\nexport type SentinelIntervalAutomationPayload = z.infer<typeof SentinelIntervalAutomationZod>\n\nexport const isSentinelIntervalAutomation: ReturnType<typeof zodIsFactory<SentinelIntervalAutomationPayload>> = zodIsFactory(SentinelIntervalAutomationZod)\nexport const asSentinelIntervalAutomation: ReturnType<typeof zodAsFactory<SentinelIntervalAutomationPayload>> = zodAsFactory(SentinelIntervalAutomationZod, 'asSentinelIntervalAutomation')\nexport const toSentinelIntervalAutomation: ReturnType<typeof zodToFactory<SentinelIntervalAutomationPayload>> = zodToFactory(SentinelIntervalAutomationZod, 'toSentinelIntervalAutomation')\n\n/** Settings for an Module Event Automation */\nexport const SentinelModuleEventAutomationZod: z.ZodMiniObject<{\n  eventName: z.ZodMiniCustom<EventName, EventName>\n  schema: z.ZodMiniLiteral<SentinelModuleEventAutomationSchema>\n  source: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>\n  type: z.ZodMiniLiteral<'event'>\n}, z.core.$strip> = z.extend(PayloadZodOfSchema(SentinelModuleEventAutomationSchema), {\n  eventName: z.custom<EventName>(),\n  source: z.custom<ModuleIdentifier>(),\n  type: z.literal('event'),\n})\n\nexport type SentinelModuleEventAutomationPayload = z.infer<typeof SentinelModuleEventAutomationZod>\n\nexport const isSentinelModuleEventAutomation: ReturnType<typeof zodIsFactory<SentinelModuleEventAutomationPayload>> = zodIsFactory(SentinelModuleEventAutomationZod)\nexport const asSentinelModuleEventAutomation: ReturnType<typeof zodAsFactory<SentinelModuleEventAutomationPayload>> = zodAsFactory(SentinelModuleEventAutomationZod, 'asSentinelModuleEventAutomation')\nexport const toSentinelModuleEventAutomation: ReturnType<typeof zodToFactory<SentinelModuleEventAutomationPayload>> = zodToFactory(SentinelModuleEventAutomationZod, 'toSentinelModuleEventAutomation')\n\n/** Settings for an Automation */\nexport type SentinelAutomationPayload = Payload<\n  SentinelIntervalAutomationPayload | SentinelModuleEventAutomationPayload,\n  SentinelAutomationSchema | SentinelIntervalAutomationSchema | SentinelModuleEventAutomationSchema\n>\n", "import type { WithAdditional } from '@ariestools/sdk'\nimport {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport {\n  asSchema, type Payload, type Schema,\n} from '@xyo-network/sdk-protocol'\nimport * as z from 'zod/mini'\n\nimport type { ModuleConfig } from '#module-model'\nimport { ModuleConfigZod } from '#module-model'\n\nimport type { SentinelAutomationPayload } from './Automation.ts'\nimport type { Task } from './Task.ts'\n\nexport const SentinelConfigSchema: 'network.xyo.sentinel.config' & {\n  readonly __schema: true\n} = asSchema('network.xyo.sentinel.config', true)\nexport type SentinelConfigSchema = typeof SentinelConfigSchema\n\nexport const SentinelConfigZod: z.ZodMiniObject<\n  & Omit<(typeof ModuleConfigZod)['shape'], 'schema'>\n  & { schema: z.ZodMiniLiteral<SentinelConfigSchema> }\n  & {\n    automations: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<SentinelAutomationPayload, SentinelAutomationPayload>>>\n    synchronous: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>\n    tasks: z.ZodMiniArray<z.ZodMiniCustom<Task, Task>>\n    throwErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>\n  },\n  z.core.$strip\n> = z.extend(ModuleConfigZod, {\n  schema: z.literal(SentinelConfigSchema),\n  automations: z.optional(z.array(z.custom<SentinelAutomationPayload>())),\n  synchronous: z.optional(z.boolean()),\n  tasks: z.array(z.custom<Task>()),\n  throwErrors: z.optional(z.boolean()),\n})\n\nexport type SentinelConfigBase = z.infer<typeof SentinelConfigZod>\n\nexport const isSentinelConfig: ReturnType<typeof zodIsFactory<SentinelConfigBase>> = zodIsFactory(SentinelConfigZod)\nexport const asSentinelConfig: ReturnType<typeof zodAsFactory<SentinelConfigBase>> = zodAsFactory(SentinelConfigZod, 'asSentinelConfig')\nexport const toSentinelConfig: ReturnType<typeof zodToFactory<SentinelConfigBase>> = zodToFactory(SentinelConfigZod, 'toSentinelConfig')\n\nexport type SentinelConfig<TConfig extends Payload | void = void, TSchema extends Schema | void = void> = ModuleConfig<\n  WithAdditional<\n    {\n      automations?: SentinelAutomationPayload[]\n      schema: TConfig extends Payload ? TConfig['schema'] : SentinelConfigSchema\n      synchronous?: boolean\n      tasks: Task[]\n      throwErrors?: boolean\n    },\n    TConfig\n  >,\n  TSchema\n>\n"],
+  "mappings": "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",
+  "names": ["AsObjectFactory", "AsObjectFactory", "IsObjectFactory", "zodAsFactory", "zodIsFactory", "zodToFactory", "asSchema", "PayloadZodOfSchema", "z", "zodAsFactory", "zodIsFactory", "zodToFactory", "asSchema", "z"]
+}

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

@@ -0,0 +1,2 @@
+export * from './modules/sentinel-wrapper/index.js';
+//# sourceMappingURL=sentinel-wrapper.d.ts.map

package/dist/neutral/sentinel-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentinel-wrapper.d.ts","sourceRoot":"","sources":["../../src/sentinel-wrapper.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA"}

package/dist/neutral/sentinel-wrapper.mjs

@@ -0,0 +1,31 @@
+// src/modules/sentinel-wrapper/Wrapper.ts
+import { constructableModuleWrapper, ModuleWrapper } from "#module-wrapper";
+import {
+  isSentinelInstance,
+  isSentinelModule,
+  SentinelReportQuerySchema
+} from "#sentinel-model";
+constructableModuleWrapper();
+var SentinelWrapper = class extends ModuleWrapper {
+  static instanceIdentityCheck = isSentinelInstance;
+  static moduleIdentityCheck = isSentinelModule;
+  static requiredQueries = [SentinelReportQuerySchema, ...super.requiredQueries];
+  archivists() {
+    throw new Error("Not supported");
+  }
+  async report(payloads) {
+    const queryPayload = { schema: SentinelReportQuerySchema };
+    return await this.sendQuery(queryPayload, payloads);
+  }
+  async reportQuery(payloads, account) {
+    const queryPayload = { schema: SentinelReportQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+  witnesses() {
+    throw new Error("Not supported");
+  }
+};
+export {
+  SentinelWrapper
+};
+//# sourceMappingURL=sentinel-wrapper.mjs.map

package/dist/neutral/sentinel-wrapper.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/sentinel-wrapper/Wrapper.ts"],
+  "sourcesContent": ["import type { TypeCheck } from '@ariestools/sdk'\nimport type { AccountInstance, Payload } from '@xyo-network/sdk-protocol'\n\nimport type { ArchivistInstance } from '#archivist-model'\nimport type { ModuleQueryResult, QueryableModuleTypeCheck } from '#module-model'\nimport { constructableModuleWrapper, ModuleWrapper } from '#module-wrapper'\nimport type {\n  SentinelInstance,\n  SentinelModule,\n  SentinelReportQuery,\n} from '#sentinel-model'\nimport {\n  isSentinelInstance,\n  isSentinelModule,\n  SentinelReportQuerySchema,\n} from '#sentinel-model'\nimport type { WitnessInstance } from '#witness-model'\n\nconstructableModuleWrapper()\nexport class SentinelWrapper<TModule extends SentinelModule = SentinelModule>\n  extends ModuleWrapper<TModule>\n  implements SentinelInstance<TModule['params']> {\n  static override readonly instanceIdentityCheck: TypeCheck<SentinelInstance> = isSentinelInstance\n  static override readonly moduleIdentityCheck: QueryableModuleTypeCheck<SentinelModule> = isSentinelModule\n  static override readonly requiredQueries: string[] = [SentinelReportQuerySchema, ...super.requiredQueries]\n\n  archivists(): Promise<ArchivistInstance[]> {\n    throw new Error('Not supported')\n  }\n\n  async report(payloads?: Payload[]): Promise<Payload[]> {\n    const queryPayload: SentinelReportQuery = { schema: SentinelReportQuerySchema }\n    return await this.sendQuery(queryPayload, payloads)\n  }\n\n  async reportQuery(payloads?: Payload[], account?: AccountInstance): Promise<ModuleQueryResult> {\n    const queryPayload: SentinelReportQuery = { schema: SentinelReportQuerySchema }\n    return await this.sendQueryRaw(queryPayload, payloads, account)\n  }\n\n  witnesses(): Promise<WitnessInstance[]> {\n    throw new Error('Not supported')\n  }\n}\n"],
+  "mappings": ";AAKA,SAAS,4BAA4B,qBAAqB;AAM1D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,2BAA2B;AACpB,IAAM,kBAAN,cACG,cACuC;AAAA,EAC/C,OAAyB,wBAAqD;AAAA,EAC9E,OAAyB,sBAAgE;AAAA,EACzF,OAAyB,kBAA4B,CAAC,2BAA2B,GAAG,MAAM,eAAe;AAAA,EAEzG,aAA2C;AACzC,UAAM,IAAI,MAAM,eAAe;AAAA,EACjC;AAAA,EAEA,MAAM,OAAO,UAA0C;AACrD,UAAM,eAAoC,EAAE,QAAQ,0BAA0B;AAC9E,WAAO,MAAM,KAAK,UAAU,cAAc,QAAQ;AAAA,EACpD;AAAA,EAEA,MAAM,YAAY,UAAsB,SAAuD;AAC7F,UAAM,eAAoC,EAAE,QAAQ,0BAA0B;AAC9E,WAAO,MAAM,KAAK,aAAa,cAAc,UAAU,OAAO;AAAA,EAChE;AAAA,EAEA,YAAwC;AACtC,UAAM,IAAI,MAAM,eAAe;AAAA,EACjC;AACF;",
+  "names": []
+}

package/dist/neutral/sentinel.d.ts

@@ -0,0 +1,2 @@
+export * from './modules/sentinel/index.js';
+//# sourceMappingURL=sentinel.d.ts.map

package/dist/neutral/sentinel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentinel.d.ts","sourceRoot":"","sources":["../../src/sentinel.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAA"}

package/dist/neutral/sentinel.mjs

@@ -0,0 +1,6 @@
+// src/modules/sentinel/index.ts
+export * from "#sentinel-abstract";
+export * from "#sentinel-memory";
+export * from "#sentinel-model";
+export * from "#sentinel-wrapper";
+//# sourceMappingURL=sentinel.mjs.map

package/dist/neutral/sentinel.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/sentinel/index.ts"],
+  "sourcesContent": ["export * from '#sentinel-abstract'\nexport * from '#sentinel-memory'\nexport * from '#sentinel-model'\nexport * from '#sentinel-wrapper'\n"],
+  "mappings": ";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/neutral/witness-abstract.d.ts

@@ -0,0 +1,2 @@
+export * from './modules/witness-abstract/index.js';
+//# sourceMappingURL=witness-abstract.d.ts.map

package/dist/neutral/witness-abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-abstract.d.ts","sourceRoot":"","sources":["../../src/witness-abstract.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA"}