@nodaro/sdk 2.29.0 → 2.32.0

package/dist/entries/copilot.d.cts

@@ -0,0 +1,296 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.cjs';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+/**
+ * The assistant's conversation surface (`/v1/copilot/*`) — threads, and one
+ * turn as a live stream.
+ *
+ * A thread is the conversation; a TURN is one message and everything the
+ * assistant does in answer to it. `stream` is the only method that spends: it
+ * POSTs the message and yields the turn's frames as they arrive, so a caller
+ * renders prose, tool activity and proposals live instead of waiting for a
+ * finished answer.
+ *
+ * Two shapes here are deliberately TOLERANT of a deployment that predates a
+ * field, because the SDK ships ahead of every instance it talks to:
+ *  - `surface` is optional on both {@link CopilotThread} and the `metadata`
+ *    frame — absent is a value ("this deployment does not say"), never a
+ *    default this package invents.
+ *  - An event kind this package does not model is IGNORED, not thrown: a
+ *    newer server may emit frames a caller was built before.
+ */
+/** How this thread runs what it proposes: ask first, or run within a budget. */
+type CopilotRunMode = "ask" | "auto";
+/** The thread's model rung. Absent from a server that predates it. */
+type CopilotModelTier = "economy" | "standard" | "premium";
+/**
+ * Which product the conversation belongs to.
+ *
+ * NO deployment sends this today — nothing in the platform emits it yet — and
+ * it is typed here so that the day one does, a caller reads what the server
+ * said. That is why it is OPTIONAL everywhere it appears: absent is a value
+ * ("this deployment does not say"), never a default this package invents.
+ */
+type CopilotSurface = "studio" | "workflow";
+interface CopilotThread {
+    id: string;
+    workflowId: string;
+    runMode: CopilotRunMode;
+    /** See {@link CopilotSurface} — absent means the server did not say. */
+    surface?: CopilotSurface;
+    /** Whether this thread may build nodes that publish to connected accounts. */
+    allowPublishing?: boolean;
+    modelTier?: CopilotModelTier;
+    autoRunLimitCredits: number;
+    userTurnCount: number;
+    lastMessageAt: string | null;
+    createdAt: string;
+    /** Only on {@link CopilotResource.get} — derived from a live turn. */
+    status?: "running" | "idle";
+    activeTurnId?: string | null;
+}
+/** The workflow a thread was opened on, as `create` answers it. */
+interface CopilotThreadWorkflow {
+    id: string;
+    projectId: string;
+    name: string;
+    version: number;
+}
+type CopilotMessagePart = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "tool_call";
+    id: string;
+    name: string;
+    label: string;
+    status: "finished" | "failed";
+};
+interface CopilotMessage {
+    id: string;
+    seq: number;
+    turnId: string;
+    role: "user" | "assistant";
+    createdAt: string;
+    parts: CopilotMessagePart[];
+}
+/** Open a thread on an existing workflow, or on one this call creates. */
+interface CreateCopilotThreadInput {
+    /** The workflow to work on. Give this OR `prompt`. */
+    workflowId?: string;
+    /** Start from nothing: the server creates a workflow seeded by this prompt. */
+    prompt?: string;
+    /** Name for a workflow created by `prompt` (defaults to the prompt's head). */
+    name?: string;
+}
+interface CopilotStreamOptions {
+    /** The user's turn. */
+    message: string;
+    /** The workflow version this message was composed against — a newer one 409s. */
+    baseVersion?: number;
+    /** The composer's echo of the thread's rung; the thread row stays authoritative. */
+    tier?: CopilotModelTier;
+    /**
+     * Ends the stream. The client's request timeout is NOT applied to a turn.
+     *
+     * Aborting REJECTS the iteration — with the platform's raw `AbortError`, not
+     * a `NodaroError` — whether it fires before the first frame or between two of
+     * them. Wrap the loop in `try`/`catch` if a cancelled turn is an ordinary
+     * ending in your UI. (`media.downloadVideoProgress` behaves the same way.)
+     */
+    signal?: AbortSignal;
+}
+interface CopilotToolCallFrameData {
+    id: string;
+    name: string;
+    label: string;
+    status: "started" | "finished" | "failed";
+    summary?: string;
+}
+interface CopilotWorkflowUpdateFrameData {
+    workflowId: string;
+    version: number;
+    updatedAt?: string;
+    note?: string | null;
+    addedNodeIds: string[];
+    updatedNodeIds: string[];
+    removedNodeIds: string[];
+    addedNodeTypes: string[];
+    nodeCount: number;
+    edgeCount: number;
+    adjustments: string[];
+}
+/** A file the turn wired onto a node — named on the run card, never counted. */
+interface CopilotWiredAsset {
+    id: string;
+    kind: string;
+    filename: string;
+    nodeId: string;
+}
+interface CopilotRunProposalNode {
+    id: string;
+    type: string;
+    graphVersion: number;
+    label: string;
+}
+interface CopilotRunProposalFrameData {
+    workflowId: string;
+    addedNodeTypes: string[];
+    wiredAssets?: CopilotWiredAsset[];
+    note: string | null;
+    /** Present when ONE node was proposed rather than the whole graph. */
+    node?: CopilotRunProposalNode | null;
+}
+/** A workflow the turn created — a different one from the open canvas. */
+interface CopilotWorkflowCreatedFrameData {
+    workflowId: string;
+    name: string;
+    projectId: string;
+}
+/** One thing the assistant saved to memory this turn. */
+interface CopilotMemorySavedFrameData {
+    id: string;
+    content: string;
+}
+interface CopilotMetadataFrameData {
+    threadId: string;
+    turnId: string;
+    jobId: string;
+    model: string;
+    baseVersion: number | null;
+    runMode: CopilotRunMode;
+    autoRunLimitCredits: number;
+    allowPublishing?: boolean;
+    modelTier?: CopilotModelTier;
+    /** See {@link CopilotSurface} — absent means the server did not say. */
+    surface?: CopilotSurface;
+}
+/**
+ * One frame of a turn.
+ *
+ * The union covers the frame KINDS; a frame's `data` is passed through
+ * untouched, so a field this package does not model still reaches the caller
+ * rather than being stripped on the way.
+ */
+type CopilotStreamFrame = {
+    type: "metadata";
+    data: CopilotMetadataFrameData;
+} | {
+    type: "token";
+    data: {
+        text: string;
+    };
+} | {
+    type: "tool_call";
+    data: CopilotToolCallFrameData;
+} | {
+    type: "workflow_updated";
+    data: CopilotWorkflowUpdateFrameData;
+} | {
+    type: "workflow_created";
+    data: CopilotWorkflowCreatedFrameData;
+} | {
+    type: "run_proposed";
+    data: CopilotRunProposalFrameData;
+} | {
+    type: "memory_saved";
+    data: CopilotMemorySavedFrameData;
+} | {
+    type: "usage";
+    data: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        creditsCharged: number | null;
+    };
+} | {
+    type: "done";
+    data: {
+        turnId: string;
+        messageId: string | null;
+        status: "completed" | "capped" | "cancelled";
+        finalVersion: number | null;
+    };
+} | {
+    type: "error";
+    data: {
+        code: string;
+        message: string;
+    };
+};
+declare class CopilotResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /**
+     * Open a conversation (`POST /v1/copilot/threads`) — on `workflowId`, or on
+     * a workflow the server creates from `prompt`. Re-opening a workflow that
+     * already has an active thread answers THAT thread rather than a second one.
+     */
+    create(input: CreateCopilotThreadInput): Promise<{
+        data: {
+            thread: CopilotThread;
+            workflow: CopilotThreadWorkflow;
+        };
+    }>;
+    /**
+     * The active thread for a workflow (`GET /v1/copilot/threads?workflowId=…`),
+     * or `null` when the user has none open on it.
+     */
+    list(params: {
+        workflowId: string;
+    }): Promise<{
+        data: {
+            thread: CopilotThread | null;
+        };
+    }>;
+    /**
+     * One thread with its messages (`GET /v1/copilot/threads/:id`). `after` reads
+     * only what followed that sequence number (the panel's catch-up); `limit`
+     * caps the page at the server's own ceiling.
+     */
+    get(id: string, opts?: {
+        after?: number;
+        limit?: number;
+    }): Promise<{
+        data: {
+            thread: CopilotThread;
+            messages: CopilotMessage[];
+        };
+    }>;
+    /**
+     * Close a conversation (`DELETE /v1/copilot/threads/:id`). Archival, not
+     * deletion — the messages stay readable. Refused while a turn is running.
+     */
+    archive(id: string): Promise<{
+        data: {
+            archived: true;
+        };
+    }>;
+    /**
+     * Stop the running turn (`POST /v1/copilot/threads/:id/cancel`). Answers the
+     * turn it asked to stop; the turn's own stream ends with a `done` frame.
+     */
+    cancel(id: string): Promise<{
+        data: {
+            cancelling: true;
+            turnId: string;
+        };
+    }>;
+    /**
+     * Send one message and iterate the turn's frames
+     * (`POST /v1/copilot/threads/:id/messages`, server-sent events).
+     *
+     * Deliberately NOT routed through `client.request`: that path arms an abort
+     * timer around the whole exchange, and a turn legitimately runs for minutes —
+     * inheriting `timeoutMs` would cut the assistant off mid-answer. The caller
+     * owns the lifetime instead: pass `signal` to end the stream, or stop
+     * iterating (the reader cancels the body, which ends the request).
+     *
+     * A frame kind this package does not model is skipped rather than thrown, so
+     * a newer server cannot break an older caller.
+     */
+    stream(threadId: string, opts: CopilotStreamOptions): AsyncGenerator<CopilotStreamFrame, void, undefined>;
+}
+
+export { type CopilotMemorySavedFrameData, type CopilotMessage, type CopilotMessagePart, type CopilotMetadataFrameData, type CopilotModelTier, CopilotResource, type CopilotRunMode, type CopilotRunProposalFrameData, type CopilotRunProposalNode, type CopilotStreamFrame, type CopilotStreamOptions, type CopilotSurface, type CopilotThread, type CopilotThreadWorkflow, type CopilotToolCallFrameData, type CopilotWiredAsset, type CopilotWorkflowCreatedFrameData, type CopilotWorkflowUpdateFrameData, type CreateCopilotThreadInput };

package/dist/entries/copilot.d.ts

@@ -0,0 +1,296 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.js';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+/**
+ * The assistant's conversation surface (`/v1/copilot/*`) — threads, and one
+ * turn as a live stream.
+ *
+ * A thread is the conversation; a TURN is one message and everything the
+ * assistant does in answer to it. `stream` is the only method that spends: it
+ * POSTs the message and yields the turn's frames as they arrive, so a caller
+ * renders prose, tool activity and proposals live instead of waiting for a
+ * finished answer.
+ *
+ * Two shapes here are deliberately TOLERANT of a deployment that predates a
+ * field, because the SDK ships ahead of every instance it talks to:
+ *  - `surface` is optional on both {@link CopilotThread} and the `metadata`
+ *    frame — absent is a value ("this deployment does not say"), never a
+ *    default this package invents.
+ *  - An event kind this package does not model is IGNORED, not thrown: a
+ *    newer server may emit frames a caller was built before.
+ */
+/** How this thread runs what it proposes: ask first, or run within a budget. */
+type CopilotRunMode = "ask" | "auto";
+/** The thread's model rung. Absent from a server that predates it. */
+type CopilotModelTier = "economy" | "standard" | "premium";
+/**
+ * Which product the conversation belongs to.
+ *
+ * NO deployment sends this today — nothing in the platform emits it yet — and
+ * it is typed here so that the day one does, a caller reads what the server
+ * said. That is why it is OPTIONAL everywhere it appears: absent is a value
+ * ("this deployment does not say"), never a default this package invents.
+ */
+type CopilotSurface = "studio" | "workflow";
+interface CopilotThread {
+    id: string;
+    workflowId: string;
+    runMode: CopilotRunMode;
+    /** See {@link CopilotSurface} — absent means the server did not say. */
+    surface?: CopilotSurface;
+    /** Whether this thread may build nodes that publish to connected accounts. */
+    allowPublishing?: boolean;
+    modelTier?: CopilotModelTier;
+    autoRunLimitCredits: number;
+    userTurnCount: number;
+    lastMessageAt: string | null;
+    createdAt: string;
+    /** Only on {@link CopilotResource.get} — derived from a live turn. */
+    status?: "running" | "idle";
+    activeTurnId?: string | null;
+}
+/** The workflow a thread was opened on, as `create` answers it. */
+interface CopilotThreadWorkflow {
+    id: string;
+    projectId: string;
+    name: string;
+    version: number;
+}
+type CopilotMessagePart = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "tool_call";
+    id: string;
+    name: string;
+    label: string;
+    status: "finished" | "failed";
+};
+interface CopilotMessage {
+    id: string;
+    seq: number;
+    turnId: string;
+    role: "user" | "assistant";
+    createdAt: string;
+    parts: CopilotMessagePart[];
+}
+/** Open a thread on an existing workflow, or on one this call creates. */
+interface CreateCopilotThreadInput {
+    /** The workflow to work on. Give this OR `prompt`. */
+    workflowId?: string;
+    /** Start from nothing: the server creates a workflow seeded by this prompt. */
+    prompt?: string;
+    /** Name for a workflow created by `prompt` (defaults to the prompt's head). */
+    name?: string;
+}
+interface CopilotStreamOptions {
+    /** The user's turn. */
+    message: string;
+    /** The workflow version this message was composed against — a newer one 409s. */
+    baseVersion?: number;
+    /** The composer's echo of the thread's rung; the thread row stays authoritative. */
+    tier?: CopilotModelTier;
+    /**
+     * Ends the stream. The client's request timeout is NOT applied to a turn.
+     *
+     * Aborting REJECTS the iteration — with the platform's raw `AbortError`, not
+     * a `NodaroError` — whether it fires before the first frame or between two of
+     * them. Wrap the loop in `try`/`catch` if a cancelled turn is an ordinary
+     * ending in your UI. (`media.downloadVideoProgress` behaves the same way.)
+     */
+    signal?: AbortSignal;
+}
+interface CopilotToolCallFrameData {
+    id: string;
+    name: string;
+    label: string;
+    status: "started" | "finished" | "failed";
+    summary?: string;
+}
+interface CopilotWorkflowUpdateFrameData {
+    workflowId: string;
+    version: number;
+    updatedAt?: string;
+    note?: string | null;
+    addedNodeIds: string[];
+    updatedNodeIds: string[];
+    removedNodeIds: string[];
+    addedNodeTypes: string[];
+    nodeCount: number;
+    edgeCount: number;
+    adjustments: string[];
+}
+/** A file the turn wired onto a node — named on the run card, never counted. */
+interface CopilotWiredAsset {
+    id: string;
+    kind: string;
+    filename: string;
+    nodeId: string;
+}
+interface CopilotRunProposalNode {
+    id: string;
+    type: string;
+    graphVersion: number;
+    label: string;
+}
+interface CopilotRunProposalFrameData {
+    workflowId: string;
+    addedNodeTypes: string[];
+    wiredAssets?: CopilotWiredAsset[];
+    note: string | null;
+    /** Present when ONE node was proposed rather than the whole graph. */
+    node?: CopilotRunProposalNode | null;
+}
+/** A workflow the turn created — a different one from the open canvas. */
+interface CopilotWorkflowCreatedFrameData {
+    workflowId: string;
+    name: string;
+    projectId: string;
+}
+/** One thing the assistant saved to memory this turn. */
+interface CopilotMemorySavedFrameData {
+    id: string;
+    content: string;
+}
+interface CopilotMetadataFrameData {
+    threadId: string;
+    turnId: string;
+    jobId: string;
+    model: string;
+    baseVersion: number | null;
+    runMode: CopilotRunMode;
+    autoRunLimitCredits: number;
+    allowPublishing?: boolean;
+    modelTier?: CopilotModelTier;
+    /** See {@link CopilotSurface} — absent means the server did not say. */
+    surface?: CopilotSurface;
+}
+/**
+ * One frame of a turn.
+ *
+ * The union covers the frame KINDS; a frame's `data` is passed through
+ * untouched, so a field this package does not model still reaches the caller
+ * rather than being stripped on the way.
+ */
+type CopilotStreamFrame = {
+    type: "metadata";
+    data: CopilotMetadataFrameData;
+} | {
+    type: "token";
+    data: {
+        text: string;
+    };
+} | {
+    type: "tool_call";
+    data: CopilotToolCallFrameData;
+} | {
+    type: "workflow_updated";
+    data: CopilotWorkflowUpdateFrameData;
+} | {
+    type: "workflow_created";
+    data: CopilotWorkflowCreatedFrameData;
+} | {
+    type: "run_proposed";
+    data: CopilotRunProposalFrameData;
+} | {
+    type: "memory_saved";
+    data: CopilotMemorySavedFrameData;
+} | {
+    type: "usage";
+    data: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        creditsCharged: number | null;
+    };
+} | {
+    type: "done";
+    data: {
+        turnId: string;
+        messageId: string | null;
+        status: "completed" | "capped" | "cancelled";
+        finalVersion: number | null;
+    };
+} | {
+    type: "error";
+    data: {
+        code: string;
+        message: string;
+    };
+};
+declare class CopilotResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /**
+     * Open a conversation (`POST /v1/copilot/threads`) — on `workflowId`, or on
+     * a workflow the server creates from `prompt`. Re-opening a workflow that
+     * already has an active thread answers THAT thread rather than a second one.
+     */
+    create(input: CreateCopilotThreadInput): Promise<{
+        data: {
+            thread: CopilotThread;
+            workflow: CopilotThreadWorkflow;
+        };
+    }>;
+    /**
+     * The active thread for a workflow (`GET /v1/copilot/threads?workflowId=…`),
+     * or `null` when the user has none open on it.
+     */
+    list(params: {
+        workflowId: string;
+    }): Promise<{
+        data: {
+            thread: CopilotThread | null;
+        };
+    }>;
+    /**
+     * One thread with its messages (`GET /v1/copilot/threads/:id`). `after` reads
+     * only what followed that sequence number (the panel's catch-up); `limit`
+     * caps the page at the server's own ceiling.
+     */
+    get(id: string, opts?: {
+        after?: number;
+        limit?: number;
+    }): Promise<{
+        data: {
+            thread: CopilotThread;
+            messages: CopilotMessage[];
+        };
+    }>;
+    /**
+     * Close a conversation (`DELETE /v1/copilot/threads/:id`). Archival, not
+     * deletion — the messages stay readable. Refused while a turn is running.
+     */
+    archive(id: string): Promise<{
+        data: {
+            archived: true;
+        };
+    }>;
+    /**
+     * Stop the running turn (`POST /v1/copilot/threads/:id/cancel`). Answers the
+     * turn it asked to stop; the turn's own stream ends with a `done` frame.
+     */
+    cancel(id: string): Promise<{
+        data: {
+            cancelling: true;
+            turnId: string;
+        };
+    }>;
+    /**
+     * Send one message and iterate the turn's frames
+     * (`POST /v1/copilot/threads/:id/messages`, server-sent events).
+     *
+     * Deliberately NOT routed through `client.request`: that path arms an abort
+     * timer around the whole exchange, and a turn legitimately runs for minutes —
+     * inheriting `timeoutMs` would cut the assistant off mid-answer. The caller
+     * owns the lifetime instead: pass `signal` to end the stream, or stop
+     * iterating (the reader cancels the body, which ends the request).
+     *
+     * A frame kind this package does not model is skipped rather than thrown, so
+     * a newer server cannot break an older caller.
+     */
+    stream(threadId: string, opts: CopilotStreamOptions): AsyncGenerator<CopilotStreamFrame, void, undefined>;
+}
+
+export { type CopilotMemorySavedFrameData, type CopilotMessage, type CopilotMessagePart, type CopilotMetadataFrameData, type CopilotModelTier, CopilotResource, type CopilotRunMode, type CopilotRunProposalFrameData, type CopilotRunProposalNode, type CopilotStreamFrame, type CopilotStreamOptions, type CopilotSurface, type CopilotThread, type CopilotThreadWorkflow, type CopilotToolCallFrameData, type CopilotWiredAsset, type CopilotWorkflowCreatedFrameData, type CopilotWorkflowUpdateFrameData, type CreateCopilotThreadInput };

package/dist/entries/copilot.js

@@ -0,0 +1,6 @@
+import '../chunk-ELSOVJPF.js';
+export { CopilotResource } from '../chunk-I6CXC345.js';
+import '../chunk-JMOKD6ZP.js';
+import '../chunk-JGS6YBDW.js';
+//# sourceMappingURL=copilot.js.map
+//# sourceMappingURL=copilot.js.map

package/dist/entries/copilot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"copilot.js"}

package/dist/entries/core.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+require('../chunk-X7XP5WBP.cjs');
+var chunkFB3S2FON_cjs = require('../chunk-FB3S2FON.cjs');
+require('../chunk-N6GLZOE4.cjs');
+
+
+
+Object.defineProperty(exports, "CallbackAuth", {
+  enumerable: true,
+  get: function () { return chunkFB3S2FON_cjs.CallbackAuth; }
+});
+Object.defineProperty(exports, "NodaroClientCore", {
+  enumerable: true,
+  get: function () { return chunkFB3S2FON_cjs.NodaroClientCore; }
+});
+Object.defineProperty(exports, "StaticTokenAuth", {
+  enumerable: true,
+  get: function () { return chunkFB3S2FON_cjs.StaticTokenAuth; }
+});
+Object.defineProperty(exports, "supabaseAuth", {
+  enumerable: true,
+  get: function () { return chunkFB3S2FON_cjs.supabaseAuth; }
+});
+//# sourceMappingURL=core.cjs.map
+//# sourceMappingURL=core.cjs.map

package/dist/entries/core.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"core.cjs"}

package/dist/entries/core.d.cts

@@ -0,0 +1,3 @@
+export { A as Auth, C as CallbackAuth, N as NodaroClientCore, S as StaticTokenAuth, s as supabaseAuth } from '../developer-apps-zSQXWmEG.cjs';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';

package/dist/entries/core.d.ts

@@ -0,0 +1,3 @@
+export { A as Auth, C as CallbackAuth, N as NodaroClientCore, S as StaticTokenAuth, s as supabaseAuth } from '../developer-apps-zSQXWmEG.js';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';

package/dist/entries/core.js

@@ -0,0 +1,5 @@
+import '../chunk-AUDHV3OE.js';
+export { CallbackAuth, NodaroClientCore, StaticTokenAuth, supabaseAuth } from '../chunk-GWCOKNST.js';
+import '../chunk-JGS6YBDW.js';
+//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map

package/dist/entries/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"core.js"}

package/dist/entries/creatures.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+require('../chunk-4WWSHV5G.cjs');
+var chunkHGCVWOGK_cjs = require('../chunk-HGCVWOGK.cjs');
+
+
+
+Object.defineProperty(exports, "CREATURE_ASPECT_DEFAULTS", {
+  enumerable: true,
+  get: function () { return chunkHGCVWOGK_cjs.OBJECT_ASPECT_DEFAULTS; }
+});
+Object.defineProperty(exports, "CREATURE_ASPECT_OPTIONS", {
+  enumerable: true,
+  get: function () { return chunkHGCVWOGK_cjs.OBJECT_ASPECT_OPTIONS; }
+});
+Object.defineProperty(exports, "CREATURE_ASSET_TYPES", {
+  enumerable: true,
+  get: function () { return chunkHGCVWOGK_cjs.CREATURE_ASSET_TYPES; }
+});
+Object.defineProperty(exports, "CREATURE_ATTACH_COLUMNS", {
+  enumerable: true,
+  get: function () { return chunkHGCVWOGK_cjs.CREATURE_ATTACH_COLUMNS; }
+});
+Object.defineProperty(exports, "CreaturesResource", {
+  enumerable: true,
+  get: function () { return chunkHGCVWOGK_cjs.CreaturesResource; }
+});
+//# sourceMappingURL=creatures.cjs.map
+//# sourceMappingURL=creatures.cjs.map

package/dist/entries/creatures.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"creatures.cjs"}