@rei-standard/amsg-shared 0.1.0-next.0

package/README.md

@@ -0,0 +1,253 @@
+# @rei-standard/amsg-shared
+
+Lowest layer of the ReiStandard Active Messaging ecosystem. Defines
+the **three-axis push contract** that `amsg-instant`, `amsg-server`,
+`amsg-sw`, and `amsg-client` all conform to.
+
+Zero runtime deps. Does **not** depend on any other amsg package —
+every other amsg sub-package depends on this one, never the reverse.
+
+---
+
+## Three axes
+
+A single push is described by three orthogonal axes:
+
+| Axis           | Field             | Values                                                | Defined by         |
+|----------------|-------------------|-------------------------------------------------------|--------------------|
+| Dispatch       | `messageType`     | `instant` / `fixed` / `prompted` / `auto`             | Package (fixed)    |
+| Business       | `messageSubtype`  | Any string                                            | Caller (free-form) |
+| Content        | `messageKind`     | `content` / `reasoning` / `tool_request` / `error`    | Package (fixed)    |
+
+`messageType` answers **how this push was produced** (one-shot
+`instant` worker, scheduled `fixed` ping, AI-`prompted` reply, fully
+`auto`-generated cadence). `messageKind` answers **what it carries**.
+The two are intentionally orthogonal: any `messageType` can carry any
+`messageKind`.
+
+There is also `source: 'instant' | 'scheduled'` — the **routing
+origin** (`'instant'` for `amsg-instant`, `'scheduled'` for any
+`amsg-server` output). `messageType: 'instant'` always pairs with
+`source: 'instant'`; the other three `messageType`s always pair with
+`source: 'scheduled'`.
+
+---
+
+## Common fields (every push)
+
+| Field            | Type              | Notes                                                                       |
+|------------------|-------------------|-----------------------------------------------------------------------------|
+| `messageKind`    | `MessageKind`     | Discriminator. Literal type — TS narrows on it.                             |
+| `messageType`    | `MessageType`     | Dispatch axis.                                                              |
+| `source`         | `'instant' \| 'scheduled'` | Routing origin.                                                    |
+| `messageId`      | `string`          | Unique per push. Format owned by the producer.                              |
+| `sessionId`      | `string`          | **Shared across all pushes from the same LLM round** (reasoning + content), and across all iterations of a single agentic-loop request. |
+| `timestamp`      | `string` (ISO 8601) | Producer-side wall clock.                                                 |
+| `messageSubtype` | `string?`         | Caller's business namespace. Defaults to `'chat'` at producers.             |
+| `metadata`       | `object?`         | **Caller passthrough.** Packages MUST NOT write here.                       |
+
+---
+
+## Per-kind fields
+
+### `ContentPush` — final user-facing content
+
+| Field            | Type        | Notes                                                          |
+|------------------|-------------|----------------------------------------------------------------|
+| `messageKind`    | `'content'` | Discriminator.                                                 |
+| `message`        | `string`    | The sentence/segment to display.                               |
+| `messageIndex`   | `number?`   | 1-based segment index within an N-split burst. Omit for singletons. |
+| `totalMessages`  | `number?`   | Total segments in the burst. Omit for singletons.              |
+| `title`          | `string?`   | Notification title.                                            |
+| `contactName`    | `string?`   | Sender display name.                                           |
+| `avatarUrl`      | `string \| null?` | Sender avatar URL (`https:` only — `data:` is rejected upstream). |
+| `taskId`         | `string \| null?` | Scheduled task ID (server only).                          |
+
+### `ReasoningPush` — LLM meta-thinking
+
+| Field              | Type           | Notes                                                       |
+|--------------------|----------------|-------------------------------------------------------------|
+| `messageKind`      | `'reasoning'`  | Discriminator.                                              |
+| `reasoningContent` | `string`       | Lifted from `choices[0].message.reasoning_content`.         |
+| `title`            | `string?`      |                                                             |
+| `contactName`      | `string?`      |                                                             |
+| `avatarUrl`        | `string \| null?` |                                                          |
+
+**No `messageIndex` / `totalMessages`.** Reasoning is one push per
+LLM round, never a split-burst. Those fields are absent at the type
+level on purpose — making them optional would leave callers
+wondering when they're set.
+
+Emitted **before** the matching `ContentPush` burst when the LLM
+response carried a non-empty `reasoning_content`.
+
+### `ToolRequestPush` — tool invocation request
+
+| Field         | Type             | Notes                                                       |
+|---------------|------------------|-------------------------------------------------------------|
+| `messageKind` | `'tool_request'` | Discriminator.                                              |
+| `toolCalls`   | `Array<object>`  | OpenAI `choices[0].message.tool_calls` shape, passthrough.  |
+| `title`       | `string?`        |                                                             |
+| `contactName` | `string?`        |                                                             |
+| `message`     | `string?`        | Optional human-readable tag for the request.                |
+
+Emitted by an agentic-loop hook returning
+`{ decision: 'tool-request', pushPayload }`. The client is expected
+to execute the tool and resume via `/continue`.
+
+### `ErrorPush` — producer-level error
+
+| Field         | Type      | Notes                                                                  |
+|---------------|-----------|------------------------------------------------------------------------|
+| `messageKind` | `'error'` | Discriminator.                                                         |
+| `code`        | `string`  | Stable producer-defined code, e.g. `HOOK_THREW`, `LOOP_EXCEEDED`.      |
+| `message`     | `string`  | Human-readable description.                                            |
+| `iteration`   | `number?` | Agentic-loop iteration when relevant.                                  |
+
+Replaces the legacy 0.7.0 `{ type: 'error', code: '...' }` envelope.
+The legacy `type` field is **gone** — do not look for it on
+`ErrorPush`.
+
+---
+
+## Usage
+
+### TypeScript / typed JavaScript
+
+```ts
+import {
+  type AmsgPush,
+  type ContentPush,
+  type ReasoningPush,
+  isContentPush,
+} from '@rei-standard/amsg-shared';
+
+function dispatch(push: AmsgPush) {
+  switch (push.messageKind) {
+    case 'content':
+      // push narrowed to ContentPush — push.message is `string`
+      console.log(push.message);
+      break;
+    case 'reasoning':
+      // push narrowed to ReasoningPush — push.reasoningContent is `string`
+      console.log(push.reasoningContent);
+      break;
+    case 'tool_request':
+      // push.toolCalls is `Array<object>`
+      break;
+    case 'error':
+      console.error(push.code, push.message);
+      break;
+  }
+}
+```
+
+### Builders
+
+```js
+import {
+  buildContentPush,
+  buildReasoningPush,
+  buildToolRequestPush,
+  buildErrorPush,
+} from '@rei-standard/amsg-shared';
+
+// One sentence in an N-split burst
+const content = buildContentPush({
+  messageType: 'instant',
+  source: 'instant',
+  messageId: `msg_${crypto.randomUUID()}_0`,
+  sessionId: 'sess_abc',
+  message: 'Hello!',
+  contactName: 'Rei',
+  messageIndex: 1,
+  totalMessages: 2,
+});
+
+// Reasoning emitted before the content burst
+const reasoning = buildReasoningPush({
+  messageType: 'instant',
+  source: 'instant',
+  messageId: `msg_${crypto.randomUUID()}_reasoning`,
+  sessionId: 'sess_abc', // SAME sessionId as the content above
+  reasoningContent: 'User greeted me; I should reply warmly.',
+});
+
+// Agentic-loop tool request
+const toolReq = buildToolRequestPush({
+  messageType: 'instant',
+  source: 'instant',
+  messageId: `msg_${crypto.randomUUID()}_tool`,
+  sessionId: 'sess_abc',
+  toolCalls: [{ id: 'call_0', type: 'function', function: { name: 'get_weather', arguments: '{}' } }],
+});
+
+// Producer-level error
+const error = buildErrorPush({
+  messageType: 'instant',
+  source: 'instant',
+  messageId: `msg_${crypto.randomUUID()}_err`,
+  sessionId: 'sess_abc',
+  code: 'HOOK_THREW',
+  message: 'onLLMOutput threw: ...',
+  iteration: 2,
+});
+```
+
+### Type guards
+
+```js
+import { isContentPush, isReasoningPush, isErrorPush } from '@rei-standard/amsg-shared';
+
+if (isContentPush(push)) {
+  // push.message is `string`
+}
+```
+
+---
+
+## Constants
+
+```js
+import { MESSAGE_KIND, MESSAGE_TYPE, PUSH_SOURCE } from '@rei-standard/amsg-shared';
+
+MESSAGE_KIND.CONTENT;       // 'content'
+MESSAGE_KIND.REASONING;     // 'reasoning'
+MESSAGE_KIND.TOOL_REQUEST;  // 'tool_request'
+MESSAGE_KIND.ERROR;         // 'error'
+
+MESSAGE_TYPE.INSTANT;       // 'instant'
+MESSAGE_TYPE.FIXED;         // 'fixed'
+MESSAGE_TYPE.PROMPTED;      // 'prompted'
+MESSAGE_TYPE.AUTO;          // 'auto'
+
+PUSH_SOURCE.INSTANT;        // 'instant'
+PUSH_SOURCE.SCHEDULED;      // 'scheduled'
+```
+
+---
+
+## Invariants
+
+1. **`messageKind` is a literal-type discriminator.** Producers must
+   set it via a builder (or to one of the literal values directly).
+   Never `string`-typed.
+2. **`sessionId` is stable across a single LLM round.** A
+   `ReasoningPush` and the `ContentPush`(es) it precedes share the
+   same `sessionId`. Agentic-loop multi-iteration runs reuse the
+   same `sessionId` across iterations.
+3. **`ReasoningPush` carries no `messageIndex` / `totalMessages`.**
+   Those fields belong to the content N-split burst.
+4. **`metadata` is caller-owned.** Packages must add protocol-level
+   data as top-level fields, never inside `metadata`.
+5. **`source` is the routing origin, not the dispatch type.**
+   `'instant'` ⇄ `amsg-instant`; `'scheduled'` ⇄ `amsg-server`.
+
+See [§6 of `standards/active-messaging-api.md`](../../../standards/active-messaging-api.md)
+for the wire-level contract.
+
+---
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,170 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  MESSAGE_KIND: () => MESSAGE_KIND,
+  MESSAGE_TYPE: () => MESSAGE_TYPE,
+  PUSH_SOURCE: () => PUSH_SOURCE,
+  buildContentPush: () => buildContentPush,
+  buildErrorPush: () => buildErrorPush,
+  buildReasoningPush: () => buildReasoningPush,
+  buildToolRequestPush: () => buildToolRequestPush,
+  isContentPush: () => isContentPush,
+  isErrorPush: () => isErrorPush,
+  isReasoningPush: () => isReasoningPush,
+  isToolRequestPush: () => isToolRequestPush
+});
+module.exports = __toCommonJS(src_exports);
+var MESSAGE_KIND = Object.freeze({
+  CONTENT: "content",
+  REASONING: "reasoning",
+  TOOL_REQUEST: "tool_request",
+  ERROR: "error"
+});
+var MESSAGE_TYPE = Object.freeze({
+  INSTANT: "instant",
+  FIXED: "fixed",
+  PROMPTED: "prompted",
+  AUTO: "auto"
+});
+var PUSH_SOURCE = Object.freeze({
+  INSTANT: "instant",
+  SCHEDULED: "scheduled"
+});
+function requireField(kind, field, value) {
+  if (value === void 0 || value === null || value === "") {
+    throw new Error(`[amsg-shared] ${kind}: '${field}' is required`);
+  }
+}
+function buildContentPush(args) {
+  requireField("ContentPush", "messageType", args.messageType);
+  requireField("ContentPush", "source", args.source);
+  requireField("ContentPush", "messageId", args.messageId);
+  requireField("ContentPush", "sessionId", args.sessionId);
+  if (typeof args.message !== "string") {
+    throw new Error("[amsg-shared] ContentPush: 'message' must be a string");
+  }
+  const push = {
+    messageKind: "content",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    message: args.message
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.avatarUrl !== void 0) push.avatarUrl = args.avatarUrl;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.messageIndex !== void 0) push.messageIndex = args.messageIndex;
+  if (args.totalMessages !== void 0) push.totalMessages = args.totalMessages;
+  if (args.taskId !== void 0) push.taskId = args.taskId;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildReasoningPush(args) {
+  requireField("ReasoningPush", "messageType", args.messageType);
+  requireField("ReasoningPush", "source", args.source);
+  requireField("ReasoningPush", "messageId", args.messageId);
+  requireField("ReasoningPush", "sessionId", args.sessionId);
+  if (typeof args.reasoningContent !== "string" || !args.reasoningContent) {
+    throw new Error("[amsg-shared] ReasoningPush: 'reasoningContent' must be a non-empty string");
+  }
+  const push = {
+    messageKind: "reasoning",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    reasoningContent: args.reasoningContent
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.avatarUrl !== void 0) push.avatarUrl = args.avatarUrl;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildToolRequestPush(args) {
+  requireField("ToolRequestPush", "messageType", args.messageType);
+  requireField("ToolRequestPush", "source", args.source);
+  requireField("ToolRequestPush", "messageId", args.messageId);
+  requireField("ToolRequestPush", "sessionId", args.sessionId);
+  if (!Array.isArray(args.toolCalls) || args.toolCalls.length === 0) {
+    throw new Error("[amsg-shared] ToolRequestPush: 'toolCalls' must be a non-empty array");
+  }
+  const push = {
+    messageKind: "tool_request",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    toolCalls: args.toolCalls
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.message !== void 0) push.message = args.message;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildErrorPush(args) {
+  requireField("ErrorPush", "messageType", args.messageType);
+  requireField("ErrorPush", "source", args.source);
+  requireField("ErrorPush", "messageId", args.messageId);
+  requireField("ErrorPush", "sessionId", args.sessionId);
+  requireField("ErrorPush", "code", args.code);
+  if (typeof args.message !== "string") {
+    throw new Error("[amsg-shared] ErrorPush: 'message' must be a string");
+  }
+  const push = {
+    messageKind: "error",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    code: args.code,
+    message: args.message
+  };
+  if (args.iteration !== void 0) push.iteration = args.iteration;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function isContentPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "content";
+}
+function isReasoningPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "reasoning";
+}
+function isToolRequestPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "tool_request";
+}
+function isErrorPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "error";
+}

package/dist/index.d.cts

@@ -0,0 +1,352 @@
+/**
+ * Build a {@link ContentPush}. Use this for legacy sentence-split
+ * bursts (set `messageIndex` 1-based + `totalMessages`) or for a
+ * single content push (omit both).
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.message
+ * @param {string}      [args.timestamp]      - Defaults to `new Date().toISOString()`.
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string | null} [args.avatarUrl]
+ * @param {string}      [args.messageSubtype]
+ * @param {number}      [args.messageIndex]
+ * @param {number}      [args.totalMessages]
+ * @param {string | null} [args.taskId]
+ * @param {Object}      [args.metadata]
+ * @returns {ContentPush}
+ */
+export function buildContentPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    message: string;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageSubtype?: string;
+    messageIndex?: number;
+    totalMessages?: number;
+    taskId?: string | null;
+    metadata?: any;
+}): ContentPush;
+/**
+ * Build a {@link ReasoningPush}. Producers emit this **before** any
+ * matching `ContentPush` burst when the LLM response carried a non-
+ * empty `reasoning_content`.
+ *
+ * Does NOT take `messageIndex` / `totalMessages` — reasoning is one
+ * push per LLM round.
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.reasoningContent
+ * @param {string}      [args.timestamp]
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string | null} [args.avatarUrl]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ReasoningPush}
+ */
+export function buildReasoningPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    reasoningContent: string;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageSubtype?: string;
+    metadata?: any;
+}): ReasoningPush;
+/**
+ * Build a {@link ToolRequestPush}. Caller is expected to executed
+ * tools client-side and resume via `/continue` (see `amsg-instant`
+ * README §Agentic Loop).
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {Array<Object>} args.toolCalls
+ * @param {string}      [args.timestamp]
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string}      [args.message]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ToolRequestPush}
+ */
+export function buildToolRequestPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    toolCalls: Array<any>;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    message?: string;
+    messageSubtype?: string;
+    metadata?: any;
+}): ToolRequestPush;
+/**
+ * Build an {@link ErrorPush}. Replaces the legacy
+ * `{ type: 'error', code: '...' }` envelope. The new shape carries
+ * the full common-fields set so the SW can route it through the
+ * same `messageKind` switch as the other three kinds.
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.code
+ * @param {string}      args.message
+ * @param {string}      [args.timestamp]
+ * @param {number}      [args.iteration]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ErrorPush}
+ */
+export function buildErrorPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    code: string;
+    message: string;
+    timestamp?: string;
+    iteration?: number;
+    messageSubtype?: string;
+    metadata?: any;
+}): ErrorPush;
+/**
+ * Type guard: returns true if the argument is a {@link ContentPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ContentPush}
+ */
+export function isContentPush(value: unknown): value is ContentPush;
+/**
+ * Type guard: returns true if the argument is a {@link ReasoningPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ReasoningPush}
+ */
+export function isReasoningPush(value: unknown): value is ReasoningPush;
+/**
+ * Type guard: returns true if the argument is a {@link ToolRequestPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ToolRequestPush}
+ */
+export function isToolRequestPush(value: unknown): value is ToolRequestPush;
+/**
+ * Type guard: returns true if the argument is an {@link ErrorPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ErrorPush}
+ */
+export function isErrorPush(value: unknown): value is ErrorPush;
+/**
+ * @rei-standard/amsg-shared
+ *
+ * Lowest layer of the ReiStandard Active Messaging ecosystem.
+ * Defines the three-axis push contract that `amsg-instant`,
+ * `amsg-server`, `amsg-sw`, and `amsg-client` all conform to.
+ *
+ * Three orthogonal axes:
+ *   1. messageType    — how the push was produced (instant / fixed / prompted / auto)
+ *   2. messageSubtype — caller's business classification (free-form string)
+ *   3. messageKind    — what the push carries (content / reasoning / tool_request / error)
+ *
+ * Zero runtime dependencies. The package is ESM/CJS dual-published and
+ * intentionally has no `dependencies:` entry — every other amsg sub-
+ * package depends on it, never the reverse.
+ *
+ * Types are expressed via JSDoc `@typedef` unions with literal-type
+ * discriminators so TS consumers can narrow on `messageKind`:
+ *
+ *   if (push.messageKind === 'reasoning') {
+ *     // TS knows: push is ReasoningPush, push.reasoningContent is string
+ *   }
+ */
+/**
+ * What the push carries. Fixed enum — packages must not add values.
+ *
+ * @typedef {'content' | 'reasoning' | 'tool_request' | 'error'} MessageKind
+ */
+/**
+ * How the push was produced. Fixed enum — packages must not add values.
+ *
+ * @typedef {'instant' | 'fixed' | 'prompted' | 'auto'} MessageType
+ */
+/**
+ * Which sub-package routed the push. Fixed enum — `'instant'` for
+ * `amsg-instant` (stateless one-shot), `'scheduled'` for any
+ * `amsg-server` output regardless of `messageType`. Packages must not
+ * add values.
+ *
+ * @typedef {'instant' | 'scheduled'} PushSource
+ */
+/**
+ * Runtime constant mirroring the {@link MessageKind} type. Useful for
+ * switch statements that need to enumerate every kind:
+ *
+ *   for (const kind of Object.values(MESSAGE_KIND)) { ... }
+ */
+export const MESSAGE_KIND: Readonly<{
+    CONTENT: "content";
+    REASONING: "reasoning";
+    TOOL_REQUEST: "tool_request";
+    ERROR: "error";
+}>;
+/**
+ * Runtime constant mirroring the {@link MessageType} type.
+ */
+export const MESSAGE_TYPE: Readonly<{
+    INSTANT: "instant";
+    FIXED: "fixed";
+    PROMPTED: "prompted";
+    AUTO: "auto";
+}>;
+/**
+ * Runtime constant mirroring the {@link PushSource} type.
+ */
+export const PUSH_SOURCE: Readonly<{
+    INSTANT: "instant";
+    SCHEDULED: "scheduled";
+}>;
+/**
+ * Fields present on every push, regardless of kind. Discriminator
+ * fields (`messageKind`) and kind-specific fields live on the kind
+ * interfaces below.
+ *
+ * `metadata` is a passthrough namespace owned by the caller. Packages
+ * are forbidden from writing their own fields into `metadata` — any
+ * protocol-level data goes on top-level fields.
+ */
+export type AmsgPushCommon = {
+    /**
+     * - How the push was produced.
+     */
+    messageType: MessageType;
+    /**
+     * - Which sub-package routed it.
+     */
+    source: PushSource;
+    /**
+     * - Unique per push. Format owned by the producer.
+     */
+    messageId: string;
+    /**
+     * - Shared across all pushes from one LLM round (reasoning + content) and across iterations of a single agentic-loop request.
+     */
+    sessionId: string;
+    /**
+     * - ISO 8601 timestamp at producer.
+     */
+    timestamp: string;
+    /**
+     * - Caller-defined business namespace. Defaults to 'chat' at producers.
+     */
+    messageSubtype?: string;
+    /**
+     * - Caller passthrough. Packages MUST NOT write here.
+     */
+    metadata?: any;
+};
+/**
+ * Final user-facing content. Sentence-split bursts of N use
+ * `messageIndex` (1-based) + `totalMessages` so the client can
+ * reassemble or animate.
+ */
+export type ContentPush = AmsgPushCommon & {
+    messageKind: "content";
+    message: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageIndex?: number;
+    totalMessages?: number;
+    taskId?: string | null;
+};
+/**
+ * LLM "meta-thinking" — `choices[0].message.reasoning_content` lifted
+ * out of the upstream response into its own push. Emitted **before**
+ * the matching {@link ContentPush} burst when present and non-empty.
+ *
+ * Intentionally does NOT carry `messageIndex` / `totalMessages` —
+ * reasoning is a single push per LLM round, never a split-burst.
+ * That's why those fields are absent at the type level rather than
+ * `optional` (which would leave callers wondering when they're set).
+ */
+export type ReasoningPush = AmsgPushCommon & {
+    messageKind: "reasoning";
+    reasoningContent: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+};
+/**
+ * Tool invocation request emitted by an agentic-loop hook (`decision:
+ * 'tool-request'`). The client is expected to execute the tool and
+ * resume via the producer's `/continue` endpoint.
+ *
+ * `toolCalls` mirrors the OpenAI `choices[0].message.tool_calls`
+ * shape — left as `any`-equivalent so producers can passthrough
+ * whatever OpenAI-compatible upstream returned.
+ */
+export type ToolRequestPush = AmsgPushCommon & {
+    messageKind: "tool_request";
+    toolCalls: Array<any>;
+    title?: string;
+    contactName?: string;
+    message?: string;
+};
+/**
+ * Producer-level error. Replaces the legacy
+ * `{ type: 'error', code: '...' }` envelope. `code` is a stable
+ * string; `iteration` is the agentic-loop iteration number when
+ * relevant (0 / absent otherwise).
+ */
+export type ErrorPush = AmsgPushCommon & {
+    messageKind: "error";
+    code: string;
+    message: string;
+    iteration?: number;
+};
+/**
+ * Discriminated union of all pushes the SW can receive. TS consumers
+ * `switch` on `messageKind` and the compiler narrows automatically.
+ */
+export type AmsgPush = ContentPush | ReasoningPush | ToolRequestPush | ErrorPush;
+/**
+ * What the push carries. Fixed enum — packages must not add values.
+ */
+export type MessageKind = "content" | "reasoning" | "tool_request" | "error";
+/**
+ * How the push was produced. Fixed enum — packages must not add values.
+ */
+export type MessageType = "instant" | "fixed" | "prompted" | "auto";
+/**
+ * Which sub-package routed the push. Fixed enum — `'instant'` for
+ * `amsg-instant` (stateless one-shot), `'scheduled'` for any
+ * `amsg-server` output regardless of `messageType`. Packages must not
+ * add values.
+ */
+export type PushSource = "instant" | "scheduled";

package/dist/index.d.ts

@@ -0,0 +1,352 @@
+/**
+ * Build a {@link ContentPush}. Use this for legacy sentence-split
+ * bursts (set `messageIndex` 1-based + `totalMessages`) or for a
+ * single content push (omit both).
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.message
+ * @param {string}      [args.timestamp]      - Defaults to `new Date().toISOString()`.
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string | null} [args.avatarUrl]
+ * @param {string}      [args.messageSubtype]
+ * @param {number}      [args.messageIndex]
+ * @param {number}      [args.totalMessages]
+ * @param {string | null} [args.taskId]
+ * @param {Object}      [args.metadata]
+ * @returns {ContentPush}
+ */
+export function buildContentPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    message: string;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageSubtype?: string;
+    messageIndex?: number;
+    totalMessages?: number;
+    taskId?: string | null;
+    metadata?: any;
+}): ContentPush;
+/**
+ * Build a {@link ReasoningPush}. Producers emit this **before** any
+ * matching `ContentPush` burst when the LLM response carried a non-
+ * empty `reasoning_content`.
+ *
+ * Does NOT take `messageIndex` / `totalMessages` — reasoning is one
+ * push per LLM round.
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.reasoningContent
+ * @param {string}      [args.timestamp]
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string | null} [args.avatarUrl]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ReasoningPush}
+ */
+export function buildReasoningPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    reasoningContent: string;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageSubtype?: string;
+    metadata?: any;
+}): ReasoningPush;
+/**
+ * Build a {@link ToolRequestPush}. Caller is expected to executed
+ * tools client-side and resume via `/continue` (see `amsg-instant`
+ * README §Agentic Loop).
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {Array<Object>} args.toolCalls
+ * @param {string}      [args.timestamp]
+ * @param {string}      [args.title]
+ * @param {string}      [args.contactName]
+ * @param {string}      [args.message]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ToolRequestPush}
+ */
+export function buildToolRequestPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    toolCalls: Array<any>;
+    timestamp?: string;
+    title?: string;
+    contactName?: string;
+    message?: string;
+    messageSubtype?: string;
+    metadata?: any;
+}): ToolRequestPush;
+/**
+ * Build an {@link ErrorPush}. Replaces the legacy
+ * `{ type: 'error', code: '...' }` envelope. The new shape carries
+ * the full common-fields set so the SW can route it through the
+ * same `messageKind` switch as the other three kinds.
+ *
+ * @param {Object} args
+ * @param {MessageType} args.messageType
+ * @param {PushSource}  args.source
+ * @param {string}      args.messageId
+ * @param {string}      args.sessionId
+ * @param {string}      args.code
+ * @param {string}      args.message
+ * @param {string}      [args.timestamp]
+ * @param {number}      [args.iteration]
+ * @param {string}      [args.messageSubtype]
+ * @param {Object}      [args.metadata]
+ * @returns {ErrorPush}
+ */
+export function buildErrorPush(args: {
+    messageType: MessageType;
+    source: PushSource;
+    messageId: string;
+    sessionId: string;
+    code: string;
+    message: string;
+    timestamp?: string;
+    iteration?: number;
+    messageSubtype?: string;
+    metadata?: any;
+}): ErrorPush;
+/**
+ * Type guard: returns true if the argument is a {@link ContentPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ContentPush}
+ */
+export function isContentPush(value: unknown): value is ContentPush;
+/**
+ * Type guard: returns true if the argument is a {@link ReasoningPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ReasoningPush}
+ */
+export function isReasoningPush(value: unknown): value is ReasoningPush;
+/**
+ * Type guard: returns true if the argument is a {@link ToolRequestPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ToolRequestPush}
+ */
+export function isToolRequestPush(value: unknown): value is ToolRequestPush;
+/**
+ * Type guard: returns true if the argument is an {@link ErrorPush}.
+ *
+ * @param {unknown} value
+ * @returns {value is ErrorPush}
+ */
+export function isErrorPush(value: unknown): value is ErrorPush;
+/**
+ * @rei-standard/amsg-shared
+ *
+ * Lowest layer of the ReiStandard Active Messaging ecosystem.
+ * Defines the three-axis push contract that `amsg-instant`,
+ * `amsg-server`, `amsg-sw`, and `amsg-client` all conform to.
+ *
+ * Three orthogonal axes:
+ *   1. messageType    — how the push was produced (instant / fixed / prompted / auto)
+ *   2. messageSubtype — caller's business classification (free-form string)
+ *   3. messageKind    — what the push carries (content / reasoning / tool_request / error)
+ *
+ * Zero runtime dependencies. The package is ESM/CJS dual-published and
+ * intentionally has no `dependencies:` entry — every other amsg sub-
+ * package depends on it, never the reverse.
+ *
+ * Types are expressed via JSDoc `@typedef` unions with literal-type
+ * discriminators so TS consumers can narrow on `messageKind`:
+ *
+ *   if (push.messageKind === 'reasoning') {
+ *     // TS knows: push is ReasoningPush, push.reasoningContent is string
+ *   }
+ */
+/**
+ * What the push carries. Fixed enum — packages must not add values.
+ *
+ * @typedef {'content' | 'reasoning' | 'tool_request' | 'error'} MessageKind
+ */
+/**
+ * How the push was produced. Fixed enum — packages must not add values.
+ *
+ * @typedef {'instant' | 'fixed' | 'prompted' | 'auto'} MessageType
+ */
+/**
+ * Which sub-package routed the push. Fixed enum — `'instant'` for
+ * `amsg-instant` (stateless one-shot), `'scheduled'` for any
+ * `amsg-server` output regardless of `messageType`. Packages must not
+ * add values.
+ *
+ * @typedef {'instant' | 'scheduled'} PushSource
+ */
+/**
+ * Runtime constant mirroring the {@link MessageKind} type. Useful for
+ * switch statements that need to enumerate every kind:
+ *
+ *   for (const kind of Object.values(MESSAGE_KIND)) { ... }
+ */
+export const MESSAGE_KIND: Readonly<{
+    CONTENT: "content";
+    REASONING: "reasoning";
+    TOOL_REQUEST: "tool_request";
+    ERROR: "error";
+}>;
+/**
+ * Runtime constant mirroring the {@link MessageType} type.
+ */
+export const MESSAGE_TYPE: Readonly<{
+    INSTANT: "instant";
+    FIXED: "fixed";
+    PROMPTED: "prompted";
+    AUTO: "auto";
+}>;
+/**
+ * Runtime constant mirroring the {@link PushSource} type.
+ */
+export const PUSH_SOURCE: Readonly<{
+    INSTANT: "instant";
+    SCHEDULED: "scheduled";
+}>;
+/**
+ * Fields present on every push, regardless of kind. Discriminator
+ * fields (`messageKind`) and kind-specific fields live on the kind
+ * interfaces below.
+ *
+ * `metadata` is a passthrough namespace owned by the caller. Packages
+ * are forbidden from writing their own fields into `metadata` — any
+ * protocol-level data goes on top-level fields.
+ */
+export type AmsgPushCommon = {
+    /**
+     * - How the push was produced.
+     */
+    messageType: MessageType;
+    /**
+     * - Which sub-package routed it.
+     */
+    source: PushSource;
+    /**
+     * - Unique per push. Format owned by the producer.
+     */
+    messageId: string;
+    /**
+     * - Shared across all pushes from one LLM round (reasoning + content) and across iterations of a single agentic-loop request.
+     */
+    sessionId: string;
+    /**
+     * - ISO 8601 timestamp at producer.
+     */
+    timestamp: string;
+    /**
+     * - Caller-defined business namespace. Defaults to 'chat' at producers.
+     */
+    messageSubtype?: string;
+    /**
+     * - Caller passthrough. Packages MUST NOT write here.
+     */
+    metadata?: any;
+};
+/**
+ * Final user-facing content. Sentence-split bursts of N use
+ * `messageIndex` (1-based) + `totalMessages` so the client can
+ * reassemble or animate.
+ */
+export type ContentPush = AmsgPushCommon & {
+    messageKind: "content";
+    message: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+    messageIndex?: number;
+    totalMessages?: number;
+    taskId?: string | null;
+};
+/**
+ * LLM "meta-thinking" — `choices[0].message.reasoning_content` lifted
+ * out of the upstream response into its own push. Emitted **before**
+ * the matching {@link ContentPush} burst when present and non-empty.
+ *
+ * Intentionally does NOT carry `messageIndex` / `totalMessages` —
+ * reasoning is a single push per LLM round, never a split-burst.
+ * That's why those fields are absent at the type level rather than
+ * `optional` (which would leave callers wondering when they're set).
+ */
+export type ReasoningPush = AmsgPushCommon & {
+    messageKind: "reasoning";
+    reasoningContent: string;
+    title?: string;
+    contactName?: string;
+    avatarUrl?: string | null;
+};
+/**
+ * Tool invocation request emitted by an agentic-loop hook (`decision:
+ * 'tool-request'`). The client is expected to execute the tool and
+ * resume via the producer's `/continue` endpoint.
+ *
+ * `toolCalls` mirrors the OpenAI `choices[0].message.tool_calls`
+ * shape — left as `any`-equivalent so producers can passthrough
+ * whatever OpenAI-compatible upstream returned.
+ */
+export type ToolRequestPush = AmsgPushCommon & {
+    messageKind: "tool_request";
+    toolCalls: Array<any>;
+    title?: string;
+    contactName?: string;
+    message?: string;
+};
+/**
+ * Producer-level error. Replaces the legacy
+ * `{ type: 'error', code: '...' }` envelope. `code` is a stable
+ * string; `iteration` is the agentic-loop iteration number when
+ * relevant (0 / absent otherwise).
+ */
+export type ErrorPush = AmsgPushCommon & {
+    messageKind: "error";
+    code: string;
+    message: string;
+    iteration?: number;
+};
+/**
+ * Discriminated union of all pushes the SW can receive. TS consumers
+ * `switch` on `messageKind` and the compiler narrows automatically.
+ */
+export type AmsgPush = ContentPush | ReasoningPush | ToolRequestPush | ErrorPush;
+/**
+ * What the push carries. Fixed enum — packages must not add values.
+ */
+export type MessageKind = "content" | "reasoning" | "tool_request" | "error";
+/**
+ * How the push was produced. Fixed enum — packages must not add values.
+ */
+export type MessageType = "instant" | "fixed" | "prompted" | "auto";
+/**
+ * Which sub-package routed the push. Fixed enum — `'instant'` for
+ * `amsg-instant` (stateless one-shot), `'scheduled'` for any
+ * `amsg-server` output regardless of `messageType`. Packages must not
+ * add values.
+ */
+export type PushSource = "instant" | "scheduled";

package/dist/index.mjs

@@ -0,0 +1,150 @@
+// src/index.js
+var MESSAGE_KIND = Object.freeze({
+  CONTENT: "content",
+  REASONING: "reasoning",
+  TOOL_REQUEST: "tool_request",
+  ERROR: "error"
+});
+var MESSAGE_TYPE = Object.freeze({
+  INSTANT: "instant",
+  FIXED: "fixed",
+  PROMPTED: "prompted",
+  AUTO: "auto"
+});
+var PUSH_SOURCE = Object.freeze({
+  INSTANT: "instant",
+  SCHEDULED: "scheduled"
+});
+function requireField(kind, field, value) {
+  if (value === void 0 || value === null || value === "") {
+    throw new Error(`[amsg-shared] ${kind}: '${field}' is required`);
+  }
+}
+function buildContentPush(args) {
+  requireField("ContentPush", "messageType", args.messageType);
+  requireField("ContentPush", "source", args.source);
+  requireField("ContentPush", "messageId", args.messageId);
+  requireField("ContentPush", "sessionId", args.sessionId);
+  if (typeof args.message !== "string") {
+    throw new Error("[amsg-shared] ContentPush: 'message' must be a string");
+  }
+  const push = {
+    messageKind: "content",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    message: args.message
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.avatarUrl !== void 0) push.avatarUrl = args.avatarUrl;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.messageIndex !== void 0) push.messageIndex = args.messageIndex;
+  if (args.totalMessages !== void 0) push.totalMessages = args.totalMessages;
+  if (args.taskId !== void 0) push.taskId = args.taskId;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildReasoningPush(args) {
+  requireField("ReasoningPush", "messageType", args.messageType);
+  requireField("ReasoningPush", "source", args.source);
+  requireField("ReasoningPush", "messageId", args.messageId);
+  requireField("ReasoningPush", "sessionId", args.sessionId);
+  if (typeof args.reasoningContent !== "string" || !args.reasoningContent) {
+    throw new Error("[amsg-shared] ReasoningPush: 'reasoningContent' must be a non-empty string");
+  }
+  const push = {
+    messageKind: "reasoning",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    reasoningContent: args.reasoningContent
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.avatarUrl !== void 0) push.avatarUrl = args.avatarUrl;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildToolRequestPush(args) {
+  requireField("ToolRequestPush", "messageType", args.messageType);
+  requireField("ToolRequestPush", "source", args.source);
+  requireField("ToolRequestPush", "messageId", args.messageId);
+  requireField("ToolRequestPush", "sessionId", args.sessionId);
+  if (!Array.isArray(args.toolCalls) || args.toolCalls.length === 0) {
+    throw new Error("[amsg-shared] ToolRequestPush: 'toolCalls' must be a non-empty array");
+  }
+  const push = {
+    messageKind: "tool_request",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    toolCalls: args.toolCalls
+  };
+  if (args.title !== void 0) push.title = args.title;
+  if (args.contactName !== void 0) push.contactName = args.contactName;
+  if (args.message !== void 0) push.message = args.message;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function buildErrorPush(args) {
+  requireField("ErrorPush", "messageType", args.messageType);
+  requireField("ErrorPush", "source", args.source);
+  requireField("ErrorPush", "messageId", args.messageId);
+  requireField("ErrorPush", "sessionId", args.sessionId);
+  requireField("ErrorPush", "code", args.code);
+  if (typeof args.message !== "string") {
+    throw new Error("[amsg-shared] ErrorPush: 'message' must be a string");
+  }
+  const push = {
+    messageKind: "error",
+    messageType: args.messageType,
+    source: args.source,
+    messageId: args.messageId,
+    sessionId: args.sessionId,
+    timestamp: args.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    code: args.code,
+    message: args.message
+  };
+  if (args.iteration !== void 0) push.iteration = args.iteration;
+  if (args.messageSubtype !== void 0) push.messageSubtype = args.messageSubtype;
+  if (args.metadata !== void 0) push.metadata = args.metadata;
+  return push;
+}
+function isContentPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "content";
+}
+function isReasoningPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "reasoning";
+}
+function isToolRequestPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "tool_request";
+}
+function isErrorPush(value) {
+  return !!value && typeof value === "object" && /** @type {{messageKind?: unknown}} */
+  value.messageKind === "error";
+}
+export {
+  MESSAGE_KIND,
+  MESSAGE_TYPE,
+  PUSH_SOURCE,
+  buildContentPush,
+  buildErrorPush,
+  buildReasoningPush,
+  buildToolRequestPush,
+  isContentPush,
+  isErrorPush,
+  isReasoningPush,
+  isToolRequestPush
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rei-standard/amsg-shared",
+  "version": "0.1.0-next.0",
+  "description": "ReiStandard Active Messaging shared types and push builders — the lowest layer (no deps on other amsg packages)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Tosd0/ReiStandard",
+    "directory": "packages/rei-standard-amsg/shared"
+  },
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('dist/index.d.ts', 'dist/index.d.cts')\"",
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}