experimental-ash 0.17.0 → 0.18.1

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # experimental-ash
 
+## 0.18.1
+
+### Patch Changes
+
+- 0d710b6: Fix `ResolveAgentError: Missing compiled module namespace for schedule
+source ...` when a Nitro cron fires a TypeScript schedule that declares
+  an `async run({ ... })` handler.
+
+  The compiler's runtime module map (`.ash/compile/module-map.mjs`) lists
+  every module-backed authored source the runtime needs to load lazily.
+  It already collected channels, connections, tools, hooks, the sandbox,
+  the agent config, and the model — but it silently dropped schedules.
+
+  Markdown schedules (and TypeScript schedules whose only body is a
+  `markdown` string) execute via the pre-compiled `markdown` captured in
+  the manifest, so they never tripped the gap. Schedules with a `run`
+  handler, on the other hand, must load their default export at dispatch
+  time — and that load went straight to `ResolveAgentError` because the
+  module map had no entry for `schedules/<name>.ts`.
+
+  Module-sourced schedules with `hasRun: true` are now included in the
+  compiled module map. Markdown schedules and `markdown`-only module
+  schedules are still omitted (their body lives in the manifest and the
+  dispatcher never loads the source).
+
+## 0.18.0
+
+### Minor Changes
+
+- 7304b4d: Replace the schedule `channel: receive(slack, args)` declarative form with
+  a `run` handler that receives the same `args.receive(channel, …)` route
+  handlers got in the previous release. Schedules now author one of:
+
+  - `markdown: "..."` — fire-and-forget agent invocation (channel-less,
+    output discarded). Markdown frontmatter form (`.md`) maps here.
+  - `async run({ receive, waitUntil, appAuth }) { ... }` — full handler.
+    `receive(channel, ...)` is the same cross-channel surface route
+    handlers use; `waitUntil(promise)` extends the cron task lifetime.
+
+  Migration:
+
+  ```ts
+  // before
+  export default defineSchedule({
+    cron: "0 9 * * 1-5",
+    markdown: "Post the digest.",
+    channel: receive(slack, { channelId: "C0123ABC" }),
+  });
+
+  // after
+  export default defineSchedule({
+    cron: "0 9 * * 1-5",
+    async run({ receive, waitUntil, appAuth }) {
+      waitUntil(
+        receive(slack, {
+          message: "Post the digest.",
+          args: { channelId: "C0123ABC" },
+          auth: appAuth,
+        })
+      );
+    },
+  });
+  ```
+
+  Pure-markdown schedules (both `.md` form and `.ts` form with `markdown`)
+  are unchanged.
+
+  Removed: the `receive(channel, args)` schedule helper, the
+  `ChannelReceiveRef` type, the `ChannelRouteIdentityMap` compile-time
+  plumbing, the `ash-channel-identity` Rolldown plugin, and the
+  `channel`/`schedule.channel` manifest entry. Authored schedule
+  identity is now derived entirely at runtime from the channel value the
+  handler imports, matching how `args.receive(channel, …)` already works
+  in route handlers.
+
 ## 0.17.0
 
 ### Minor Changes

package/dist/docs/internals/schedule.md

@@ -1,16 +1,18 @@
 # Schedules
 
 Schedules let an authored agent run on a cron cadence. The runtime owns the
-dispatch contract; the channel layer (when present) owns delivery.
+dispatch contract; channels (when an author hands work off to one) own
+delivery.
 
 ## Authoring shape
 
 Each schedule is a single file under `schedules/`:
 
 - `schedules/<name>.{ts,cts,mts,js,cjs,mjs}` — TypeScript module with a default
-  export of `defineSchedule({ cron, markdown, channel? })`.
+  export of `defineSchedule({ cron, markdown? | run? })`. Exactly one of
+  `markdown` (fire-and-forget) or `run` (handler) is provided.
 - `schedules/<name>.md` — markdown with frontmatter (`cron:`) and the body as
-  the prompt. The markdown form does not support a channel.
+  the prompt. Always fire-and-forget; markdown form cannot declare `run`.
 
 Recursive nesting is supported. The schedule name is derived from the relative
 path under `schedules/` minus the file extension
@@ -28,40 +30,45 @@ to the unified `discoverNamedSourceDirectory` walker with
 hydrates each `ScheduleSourceRef` into a `CompiledScheduleDefinition`:
 
 - TypeScript modules go through `loadModuleBackedDefinition` and
-  `normalizeScheduleDefinition` (rejects unknown keys).
+  `normalizeScheduleDefinition` (rejects unknown keys; enforces the
+  `markdown` / `run` exclusivity rule).
 - Markdown sources have already been lowered at discovery time; the compiler
   re-runs `normalizeScheduleDefinition` for type safety.
-- When `channel` is present, the compiler resolves the imported route to a
-  channel name through the `channelIdentityMap` built when channels were
-  loaded. Plain `{ name, args }` literals are accepted as a test-fixture
-  fallback.
-- The compiled `markdown` field is `definition.markdown.trim()`.
+- The compiled entry carries `hasRun: boolean` plus an optional `markdown`
+  string. The schedule's TypeScript module (for `hasRun` schedules) is
+  loaded at dispatch time via the standard module map; the compiler does
+  not bake the handler into the manifest.
 - The schedule name is derived from the logical path
   (`stripLogicalPathExtension(...).replace(/^schedules\//, "")`).
 
 ## Runtime
 
-`ScheduleDispatcher.trigger` (`packages/ash/src/channel/schedule.ts`) takes
-two paths:
+`ScheduleDispatcher.trigger` (`packages/ash/src/channel/schedule.ts`) builds
+`ScheduleHandlerArgs` (a subset of `RouteHandlerArgs`) against the
+request-scoped channel bundle and routes on the schedule shape:
 
-- **With a channel:** resolve the channel by name, call its `receive()` with
-  `{ message: markdown, args, auth: APP_AUTH }`. The channel handles delivery
-  through its normal code path.
-- **Without a channel:** start a session via `runtime.run({...})` directly with
-  a minimal `{ kind: "schedule" }` adapter, `auth: APP_AUTH`, `mode: "task"`,
-  and the schedule's `markdown` as the seed message. Output is discarded; the
-  agent can still call tools, log, or hit backends.
+- **Handler (`run`):** invoke `definition.run(args)`. The handler decides
+  control flow; `args.receive(channel, …)` hands the work off to a channel,
+  `args.waitUntil(promise)` keeps the Nitro task open until the promise
+  settles. `appAuth` is the framework app principal pre-built for
+  convenience.
+- **Markdown:** the dispatcher synthesizes a channel-less run by calling
+  `runtime.run({ adapter: SCHEDULE_ADAPTER, mode: "task", auth: APP_AUTH,
+input: { message: markdown } })`. Output is discarded; the agent can still
+  call tools, log, or hit backends.
 
 Both branches use the framework app principal: `principalId: "ash:app"`,
 `principalType: "runtime"`.
 
-## Why markdown form omits channel
+`SCHEDULE_ADAPTER` is registered in `FRAMEWORK_ADAPTERS`
+(`runtime/channels/registry.ts`) so the adapter registry can rehydrate
+`{ kind: "schedule" }` at every workflow step boundary.
 
-A typed `receive(channel, args)` reference depends on importing the channel
-module so the route's args type is in scope. Markdown frontmatter has no such
-import boundary — args would have to be opaque `Record<string, unknown>`,
-losing the type safety that makes `receive()` worth using. The simple,
-type-safe answer is: if you need a channel, write a `.ts` schedule.
+## Why markdown form omits `run`
+
+Markdown frontmatter has no JavaScript scope; declaring a handler requires
+TypeScript anyway. Markdown stays the path for fire-and-forget prompts;
+`.ts` schedules cover everything else.
 
 ## Nitro task wiring
 
@@ -73,7 +80,8 @@ event name plus a baked-in artifacts config.
 
 ## Tests
 
-- `src/channel/schedule.test.ts` — dispatcher behavior in both branches.
+- `src/channel/schedule.test.ts` — dispatcher behavior for both handler and
+  markdown branches plus the `waitUntil` accumulator.
 - `src/discover/agent.integration.test.ts` — discovery shapes including
   recursive nesting, markdown form, .md/.ts collision, legacy migration
   diagnostic, and unsupported leaves.
@@ -83,6 +91,9 @@ event name plus a baked-in artifacts config.
   — runtime resolution and Nitro task registration with mixed module/markdown
   schedules.
 - `test/scenarios/compile-agent.scenario.test.ts` — end-to-end compile with
-  module + markdown schedules including the no-channel form.
+  module + markdown schedules in both forms.
+- `test/scenarios/schedule-trigger.scenario.test.ts` — markdown schedule
+  end-to-end through the real dispatcher, including the SCHEDULE_ADAPTER
+  step-boundary rehydration.
 - `test/scenarios/runtime-loaders.scenario.test.ts` — runtime artifact
   loaders round-trip.

package/dist/docs/public/schedules.md

@@ -1,9 +1,9 @@
 ---
 title: "Schedules"
-description: "Define recurring cron jobs that run an agent and optionally deliver the result through a channel."
+description: "Define recurring cron jobs that run an agent and optionally hand off to a channel."
 ---
 
-Schedules let an agent initiate recurring work — digests, syncs, maintenance, heartbeat checks — on a cron cadence. The agent can either deliver its output through a channel (e.g. Slack) or run fire-and-forget while calling tools, hitting backends, or writing logs.
+Schedules let an agent initiate recurring work — digests, syncs, maintenance, heartbeat checks — on a cron cadence. Each schedule is either a fire-and-forget markdown prompt or a TypeScript handler that decides what to do (typically by handing the work off to a channel).
 
 Schedules live under `schedules/` at the root agent package.
 
@@ -11,62 +11,77 @@ Schedules live under `schedules/` at the root agent package.
 
 - schedules are root-only — local subagents cannot declare `schedules/`
 - a schedule is a single file: `<name>.ts` or `<name>.md`
-- the markdown form does not support targeting a channel — use the `.ts` form for that
-- the channel argument is **optional**
+- every schedule provides exactly one of `markdown` (fire-and-forget) or `run` (handler)
+- markdown-form (`.md`) schedules cannot declare a handler — use `.ts` for that
 
 ## Authoring shapes
 
-### TypeScript
+### TypeScript handler (`run`)
+
+Use a handler when the schedule should deliver to a channel, branch on conditions, or compute args at fire time. The handler receives a tight subset of `RouteHandlerArgs`:
 
 ```ts
 // agent/schedules/daily-digest.ts
-import { defineSchedule, receive } from "experimental-ash/schedules";
+import { defineSchedule } from "experimental-ash/schedules";
 
 import slack from "../channels/slack.js";
 
 export default defineSchedule({
   cron: "0 9 * * 1-5",
-  markdown: "Summarize yesterday's activity and post the digest.",
-  channel: receive(slack, { channelId: "C0123ABC" }),
+  async run({ receive, waitUntil, appAuth }) {
+    waitUntil(
+      receive(slack, {
+        message: "Summarize yesterday's activity and post the digest.",
+        args: { channelId: "C0123ABC" },
+        auth: appAuth,
+      }),
+    );
+  },
 });
 ```
 
+`ScheduleHandlerArgs`:
+
+- `receive(channel, { message, args, auth })` — same contract as a route handler's [`args.receive`](./channels/README.md#cross-channel-hand-off). Hands the work off to a channel's authored `receive` hook.
+- `waitUntil(promise)` — extends the cron task's lifetime past handler return so in-flight work settles before the Nitro task completes.
+- `appAuth` — pre-built APP auth context (`{ authenticator: "app", principalId: "ash:app", principalType: "runtime" }`). Pass to `receive(..., { auth: appAuth })` for schedules that run on behalf of the agent itself.
+
 #### Announce-then-deliver
 
-A schedule can post an anchor card before the agent runs so the thread shows
-"what this is about" up front; the agent's reply then lands threaded under
-that card. Same `initialPost` field [Slack's `receive`](./channels/README.md#cross-channel-hand-off)
-accepts on the route-handler side:
+A handler that hands off to Slack can post an anchor card before the agent runs so the thread shows "what this is about" up front; the agent's reply then lands threaded under that card. Same `initialPost` field [Slack's `receive`](./channels/README.md#cross-channel-hand-off) accepts from a route handler:
 
 ```ts
 // agent/schedules/deploy-digest.ts
-import { defineSchedule, receive } from "experimental-ash/schedules";
+import { defineSchedule } from "experimental-ash/schedules";
 import { Card, CardText } from "experimental-ash/channels/slack";
 
 import slack from "../channels/slack.js";
 
 export default defineSchedule({
   cron: "0 17 * * 1-5",
-  markdown: "Summarize today's production deploys.",
-  channel: receive(slack, {
-    channelId: "C0123ABC",
-    initialPost: {
-      card: Card({ children: [CardText("Daily Deploy Digest")] }),
-      fallbackText: "Daily Deploy Digest",
-    },
-  }),
+  async run({ receive, waitUntil, appAuth }) {
+    waitUntil(
+      receive(slack, {
+        message: "Summarize today's production deploys.",
+        args: {
+          channelId: "C0123ABC",
+          initialPost: {
+            card: Card({ children: [CardText("Daily Deploy Digest")] }),
+            fallbackText: "Daily Deploy Digest",
+          },
+        },
+        auth: appAuth,
+      }),
+    );
+  },
 });
 ```
 
-`threadTs` and `initialPost` are mutually exclusive: pass `threadTs` to join
-an existing thread, or `initialPost` to anchor a new one.
+`threadTs` and `initialPost` are mutually exclusive on Slack receive args. The anchor card's `ts` becomes the session's continuation token, so any later `@mention` reply in that thread resumes the same session — a digest that sparks a question can be answered in-thread without spinning up a new session.
 
-The anchor card's `ts` is the session's continuation token, so any later `@mention`
-reply in that thread resumes the same session. A nightly digest schedule whose digest
-sparks a question can be answered in-thread without spinning up a new session — the
-schedule's run and the operator's follow-up share one history.
+### Markdown (`markdown`)
 
-Without a channel — the agent runs and the output is discarded:
+Fire-and-forget: the agent runs the prompt and the output is discarded. The agent is still free to call tools, write to backends, log, etc.
 
 ```ts
 // agent/schedules/heartbeat.ts
@@ -78,7 +93,7 @@ export default defineSchedule({
 });
 ```
 
-### Markdown
+Markdown frontmatter form:
 
 ```md
 ## <!-- agent/schedules/cleanup.md -->
@@ -88,7 +103,7 @@ export default defineSchedule({
 Sweep stale workflow state.
 ```
 
-The body is the prompt. The frontmatter accepts `cron` only — markdown-form schedules cannot reference a channel.
+The body is the prompt. The frontmatter accepts `cron` only.
 
 ## Recursive nesting
 
@@ -108,62 +123,40 @@ agent/schedules/
 ```ts
 interface ScheduleDefinition {
   cron: string;
-  markdown: string;
-  channel?: ChannelReceiveRef<unknown>;
+  markdown?: string;
+  run?: (args: ScheduleHandlerArgs) => Promise<void> | void;
 }
-```
-
-- `cron` (required) — a cron expression for when the schedule fires
-- `markdown` (required) — the prompt the agent receives when the schedule runs
-- `channel` (optional) — a typed channel reference produced by `receive(channel, args)`
-
-The `markdown` field is the prompt body — the same convention used by `defineInstructions({ markdown })` and `defineSkill({ markdown })`.
-
-## Channel targeting
-
-When a schedule should deliver its output through a channel, use the `receive(channel, args)` helper from `experimental-ash/schedules`:
 
-```ts
-import { receive } from "experimental-ash/schedules";
-import slack from "../channels/slack.js";
-
-receive(slack, { channelId: "C0123ABC" });
+interface ScheduleHandlerArgs {
+  receive: CrossChannelReceiveFn;
+  waitUntil: (task: Promise<unknown>) => void;
+  appAuth: SessionAuthContext;
+}
 ```
 
-The `args` object's shape is inferred from the channel's typed receive route — Slack requires `channelId`; other channels define their own args shape. At compile time, Ash validates that the channel reference resolves to an authored channel under `agent/channels/` whose route implements a `receive()` method.
+Exactly one of `markdown` or `run` must be provided. `defineSchedule` is a pass-through that exists to attach TypeScript types — it does not validate at authoring time; the compiler enforces the exclusivity rule.
 
 ## Runtime behavior
 
 When a schedule fires, the dispatcher takes one of two paths:
 
-### With a channel
+### Handler form (`run`)
 
-1. The dispatcher resolves the channel route by name.
-2. It calls `route.receive()` with the schedule's `markdown` and the channel-specific `args`.
-3. The channel builds its adapter, starts a session, and handles output delivery the same way it handles webhook-initiated messages.
+1. The dispatcher loads the schedule's compiled module and reads `definition.run`.
+2. It builds `ScheduleHandlerArgs` against the request-scoped channel bundle and invokes `run(args)`.
+3. The handler decides everything: which channels to target, what auth to use, whether to short-circuit on holidays, etc.
+4. Any promises the handler passes to `waitUntil` are awaited before the Nitro task settles.
 
-### Without a channel
+### Markdown form
 
-1. The dispatcher starts a session through the runtime directly with a minimal scheduled-task adapter.
+1. The dispatcher starts a session through the runtime directly with the framework-owned `SCHEDULE_ADAPTER`.
 2. The agent runs in **task mode** with the app principal.
-3. Output is discarded — but the agent is still free to call tools, write to backends, log, etc.
+3. Output is discarded.
 
 In both cases, the schedule session uses the **app principal**: `getSession().auth.current` and `getSession().auth.initiator` are set to `"ash:app"` with `principalType: "runtime"`.
 
 The session goes through the same durable runtime engine as any other Ash session.
 
-## Migrating from the legacy directory form
-
-The directory form (`schedules/<name>/schedule.ts` + `schedules/<name>/prompt.md`) is no longer supported. To migrate, collapse each directory into a single file:
-
-```text
-agent/schedules/daily-digest/schedule.ts   →   agent/schedules/daily-digest.ts
-agent/schedules/daily-digest/prompt.md     →   inlined as `markdown:` on
-                                                the `defineSchedule({...})` call
-```
-
-Discovery emits a clear migration diagnostic when it sees a legacy directory layout.
-
 ## When to use a schedule
 
 Use a schedule when the agent should initiate work on its own cadence:

package/dist/src/channel/schedule.d.ts

@@ -1,53 +1,66 @@
 import type { ChannelAdapter } from "#channel/adapter.js";
 import { type Session } from "#channel/session.js";
-import type { Runtime } from "#channel/types.js";
+import type { Runtime, SessionAuthContext } from "#channel/types.js";
+import type { ScheduleRunHandler } from "#public/definitions/schedule.js";
 import type { ResolvedChannelDefinition } from "#runtime/types.js";
 /**
- * Durable adapter kind used when a schedule triggers a session that does
- * not target a channel.
+ * Pre-built application auth context handed to schedules. Schedules
+ * run on behalf of the agent itself, not a downstream user.
+ */
+export declare const SCHEDULE_APP_AUTH: SessionAuthContext;
+/**
+ * Durable adapter kind used when a schedule fires without targeting a
+ * channel — the markdown form, and the synthesized run the dispatcher
+ * builds for it.
  *
  * Framework-owned — authored code never constructs a schedule adapter
- * directly. Emitted by {@link ScheduleDispatcher.trigger} when the
- * authored schedule has no `channel` field (the only path available to
- * markdown schedules, which are forbidden from declaring a channel).
+ * directly. Registered in `FRAMEWORK_ADAPTERS`.
  */
 export declare const SCHEDULE_ADAPTER_KIND = "schedule";
+export declare const SCHEDULE_ADAPTER: ChannelAdapter;
 /**
- * Framework adapter installed for channel-less schedules.
- *
- * Carries no behavior — it is a bare discriminator so the runtime adapter
- * registry can rehydrate `{ kind: "schedule" }` at every workflow step
- * boundary. Registered in `FRAMEWORK_ADAPTERS`
- * (`runtime/channels/registry.ts`).
+ * Loaded shape of one schedule for the dispatcher. Either `run` is
+ * defined (authored handler) or `markdown` is defined (fire-and-forget).
  */
-export declare const SCHEDULE_ADAPTER: ChannelAdapter;
-type ScheduleChannel = Pick<ResolvedChannelDefinition, "receive" | "adapter">;
-export interface ScheduleTriggerInput {
-    readonly channel?: {
-        readonly name: string;
-        readonly args: Readonly<Record<string, unknown>>;
-    };
-    readonly markdown: string;
+export interface ScheduleDispatchInput {
     readonly scheduleId: string;
+    readonly run?: ScheduleRunHandler;
+    readonly markdown?: string;
 }
 /**
- * Dispatcher for scheduled task execution.
+ * Dispatches scheduled task execution.
  *
- * When the schedule targets a channel, hands the message off to
- * `route.receive(input, { send })` — the channel author's normal entry
- * point. When the schedule has no channel, starts the session through
- * the runtime directly with a minimal schedule adapter. Both branches
- * return a `Session` and let the workflow runtime own terminal
- * completion, matching the fire-and-forget semantics HTTP routes already
- * use.
+ * For handler schedules: builds {@link ScheduleHandlerArgs} against the
+ * request-scoped channel bundle and invokes the author's `run`. The
+ * author owns control flow — `args.receive(channel, …)` hands work off
+ * to a channel; `args.waitUntil(promise)` extends the task lifetime
+ * so the dispatcher awaits in-flight work before settling.
+ *
+ * For markdown schedules: synthesizes a channel-less run that starts a
+ * session with {@link SCHEDULE_ADAPTER} in task mode and the markdown
+ * body as the message.
+ *
+ * Returns a {@link ScheduleDispatchResult} carrying any sessions the
+ * handler started (for telemetry / task-result observability) and the
+ * `waitUntil` promises the handler registered.
  */
+export interface ScheduleDispatchResult {
+    readonly sessions: readonly Session[];
+    readonly waitUntilTasks: readonly Promise<unknown>[];
+}
 export declare class ScheduleDispatcher {
     private readonly runtime;
-    private readonly resolveChannel;
+    private readonly channels;
     constructor(config: {
         readonly runtime: Runtime;
-        readonly resolveChannel: (channelName: string) => Promise<ScheduleChannel>;
+        readonly channels: readonly ResolvedChannelDefinition[];
     });
-    trigger(input: ScheduleTriggerInput): Promise<Session>;
+    trigger(input: ScheduleDispatchInput): Promise<ScheduleDispatchResult>;
+    private runMarkdown;
 }
-export {};
+/**
+ * Convenience: extract a `run` function from one loaded schedule module
+ * value, or throw with the file path so misconfigured modules fail
+ * obviously instead of crashing deep inside the dispatcher.
+ */
+export declare function expectScheduleRun(value: unknown, logicalPath: string, exportName: string | undefined): ScheduleRunHandler;

package/dist/src/channel/schedule.js

@@ -1,68 +1,81 @@
-import { invokeChannelReceive } from "#channel/cross-channel-receive.js";
+import { createCrossChannelReceiveFn } from "#channel/cross-channel-receive.js";
 import { createSession } from "#channel/session.js";
-const APP_AUTH = {
+import { expectFunction } from "#internal/authored-module.js";
+/**
+ * Pre-built application auth context handed to schedules. Schedules
+ * run on behalf of the agent itself, not a downstream user.
+ */
+export const SCHEDULE_APP_AUTH = {
     attributes: {},
     authenticator: "app",
     principalId: "ash:app",
     principalType: "runtime",
 };
 /**
- * Durable adapter kind used when a schedule triggers a session that does
- * not target a channel.
+ * Durable adapter kind used when a schedule fires without targeting a
+ * channel — the markdown form, and the synthesized run the dispatcher
+ * builds for it.
  *
  * Framework-owned — authored code never constructs a schedule adapter
- * directly. Emitted by {@link ScheduleDispatcher.trigger} when the
- * authored schedule has no `channel` field (the only path available to
- * markdown schedules, which are forbidden from declaring a channel).
+ * directly. Registered in `FRAMEWORK_ADAPTERS`.
  */
 export const SCHEDULE_ADAPTER_KIND = "schedule";
-/**
- * Framework adapter installed for channel-less schedules.
- *
- * Carries no behavior — it is a bare discriminator so the runtime adapter
- * registry can rehydrate `{ kind: "schedule" }` at every workflow step
- * boundary. Registered in `FRAMEWORK_ADAPTERS`
- * (`runtime/channels/registry.ts`).
- */
 export const SCHEDULE_ADAPTER = {
     kind: SCHEDULE_ADAPTER_KIND,
 };
-/**
- * Dispatcher for scheduled task execution.
- *
- * When the schedule targets a channel, hands the message off to
- * `route.receive(input, { send })` — the channel author's normal entry
- * point. When the schedule has no channel, starts the session through
- * the runtime directly with a minimal schedule adapter. Both branches
- * return a `Session` and let the workflow runtime own terminal
- * completion, matching the fire-and-forget semantics HTTP routes already
- * use.
- */
 export class ScheduleDispatcher {
     runtime;
-    resolveChannel;
+    channels;
     constructor(config) {
         this.runtime = config.runtime;
-        this.resolveChannel = config.resolveChannel;
+        this.channels = config.channels;
     }
     async trigger(input) {
-        if (input.channel === undefined) {
-            const handle = await this.runtime.run({
-                adapter: SCHEDULE_ADAPTER,
-                auth: APP_AUTH,
-                input: { message: input.markdown },
-                mode: "task",
-            });
-            return createSession(handle.sessionId, handle.continuationToken, this.runtime);
+        const sessions = [];
+        const waitUntilTasks = [];
+        const receive = createCrossChannelReceiveFn(this.runtime, this.channels);
+        const args = {
+            appAuth: SCHEDULE_APP_AUTH,
+            receive: async (channel, options) => {
+                const session = await receive(channel, options);
+                sessions.push(session);
+                return session;
+            },
+            waitUntil(task) {
+                waitUntilTasks.push(task);
+            },
+        };
+        if (input.run) {
+            await input.run(args);
         }
-        const { channel } = input;
-        const route = await this.resolveChannel(channel.name);
-        return await invokeChannelReceive({
-            runtime: this.runtime,
-            target: { name: channel.name, receive: route.receive, adapter: route.adapter },
-            input: { message: input.markdown, args: channel.args, auth: APP_AUTH },
-            describeMissingReceive: () => `Schedule "${input.scheduleId}" targets channel "${channel.name}" but that channel does not implement receive().`,
-            describeMissingAdapter: () => `Schedule "${input.scheduleId}" targets channel "${channel.name}" but that channel has no adapter — cannot build send().`,
+        else if (input.markdown !== undefined) {
+            const session = await this.runMarkdown(input.markdown);
+            sessions.push(session);
+        }
+        else {
+            throw new Error(`Schedule "${input.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);
+        }
+        return { sessions, waitUntilTasks };
+    }
+    async runMarkdown(markdown) {
+        const handle = await this.runtime.run({
+            adapter: SCHEDULE_ADAPTER,
+            auth: SCHEDULE_APP_AUTH,
+            input: { message: markdown },
+            mode: "task",
         });
+        return createSession(handle.sessionId, handle.continuationToken, this.runtime);
+    }
+}
+/**
+ * Convenience: extract a `run` function from one loaded schedule module
+ * value, or throw with the file path so misconfigured modules fail
+ * obviously instead of crashing deep inside the dispatcher.
+ */
+export function expectScheduleRun(value, logicalPath, exportName) {
+    const definition = value;
+    if (definition === null || typeof definition !== "object") {
+        throw new Error(`Schedule export "${exportName ?? "default"}" from "${logicalPath}" must be an object.`);
     }
+    return expectFunction(definition.run, `Expected the schedule export "${exportName ?? "default"}" from "${logicalPath}" to export a \`run\` handler function.`);
 }

package/dist/src/chunks/authored-module-loader-XcFLnl49.js

@@ -0,0 +1,2 @@
+import{createRequire as e}from"node:module";import{dirname as t,join as n,resolve as r,sep as i}from"node:path";import{createHash as a}from"node:crypto";import{existsSync as o,mkdirSync as s,readFileSync as c,writeFileSync as l}from"node:fs";import{pathToFileURL as u}from"node:url";function d(e,t){return e[t.exportName??`default`]}async function f(e){return typeof e==`function`?await e():e}function p(e,t){if(typeof e!=`object`||!e||Array.isArray(e))throw Error(t);return e}function m(e,t){if(typeof e!=`string`)throw Error(t);return e}function h(e,t){if(typeof e!=`function`)throw Error(t);return e}function g(e,t){let n=p(e,t),r={};for(let[e,i]of Object.entries(n))r[e]=p(i,t);return r}function _(e,t,n){let r=new Set(t);for(let t of Object.keys(e))if(!r.has(t))throw Error(`${n} Unknown key "${t}".`)}function v(e,t,n){let r=e[t];if(r===void 0)return;let i=p(r,n),a={};for(let[e,t]of Object.entries(i))a[e]=m(t,n);return a}let y,b;function x(){return y??=(async()=>await import(u(e(e(import.meta.url).resolve(`nitro/package.json`)).resolve(`rolldown`)).href))(),y}function S(){return b??=(async()=>await import(u(e(e(import.meta.url).resolve(`nitro/package.json`)).resolve(`rolldown/parseAst`)).href))(),b}async function C(e){let{build:t}=await x();return await t(e)}function w(e,t){let n=e.output.filter(e=>e.type===`chunk`),r=n[0];if(r===void 0||n.length!==1)throw Error(`Expected one bundled ${t}.`);return r}const T=[{importLine:`import { fileURLToPath as __ashFileURLToPath } from "node:url";`,declarationLine:`const __filename = __ashFileURLToPath(import.meta.url);`,bindingPattern:/^(?:const|let|var)\s+__filename\b/m},{importLine:`import { dirname as __ashDirname } from "node:path";`,declarationLine:`const __dirname = __ashDirname(__filename);`,bindingPattern:/^(?:const|let|var)\s+__dirname\b/m}],E={importLine:`import { createRequire as __ashCreateRequire } from "node:module";`,declarationLine:`const require = __ashCreateRequire(import.meta.url);`,bindingPattern:/^(?:const|let|var)\s+require\b/m};function D(e,t={}){let n=[...T];t.includeRequire===!0&&n.push(E);let r=[],i=[];for(let t of n)t.bindingPattern.test(e)||(r.push(t.importLine),i.push(t.declarationLine));return i.length===0?``:[...r,...i].join(`
+`)}function O(e={}){return{name:`ash-node-esm-compat-banner`,renderChunk(t){let n=D(t,e);return n===``?null:{code:`${n}\n${t}`}}}}const k=/\.[cm]?[jt]sx?$/,A=n(`node_modules`,`.cache`,`experimental-ash`,`authored-modules`),j=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`],M=new Map;function N(e){let t=r(e),n=M.get(t);if(n!==void 0)return n;let i=(async()=>{try{return await P(e)}finally{M.delete(t)}})();return M.set(t,i),i}async function P(e){return p(k.test(e)?await I(e):await import(F(e)),`Expected "${e}" to export a module namespace object.`)}function F(e){let t=e.replaceAll(`\\`,`/`);return/^[A-Za-z]:\//.test(t)?`file:///${encodeURI(t)}`:t.startsWith(`/`)?`file://${encodeURI(t)}`:t}async function I(e){let t=q(e),r=n(t,`tsconfig.json`),i=R({tsconfigPath:r}),c=w(await C({cwd:t,input:e,platform:`node`,plugins:[O({includeRequire:!0}),L(t),i].filter(e=>e!==null),resolve:{extensions:[...j]},tsconfig:o(r)?r:!1,write:!1,output:{comments:!1,format:`esm`,sourcemap:`inline`}}),`authored module for "${e}"`),u=a(`sha1`).update(e).update(`\0`).update(c.code).digest(`hex`),d=n(t,A),f=n(d,`${u}.mjs`);return o(f)||(s(d,{recursive:!0}),l(f,c.code)),await import(`${F(f)}?v=${u}`)}function L(e){return{name:`ash-package-boundary`,async resolveId(t,n,i){if(!U(t))return;if(W(t))return{external:!0,id:t};let a=n===void 0||n.startsWith(`\0`)?void 0:r(n);if(a!==void 0&&K(a,e)){let e=await this.resolve(t,n,{kind:i.kind,skipSelf:!0});if(e===null||typeof e.id!=`string`||G(e.id))return{external:!0,id:t}}}}}function R(e){let t=z(e);return t.length===0?null:{name:`ash-tsconfig-path-alias`,resolveId(e){for(let n of t){let t=B(n.pattern,e);if(t!==null)for(let e of n.targets){let n=V(e,t);if(n!==null)return n}}}}}function z(e){if(!o(e.tsconfigPath))return[];try{let n=JSON.parse(c(e.tsconfigPath,`utf8`)),i=n.compilerOptions?.paths;if(typeof i!=`object`||!i||Array.isArray(i))return[];let a=typeof n.compilerOptions?.baseUrl==`string`?n.compilerOptions.baseUrl:`.`,o=r(t(e.tsconfigPath),a);return Object.entries(i).flatMap(([e,t])=>{if(!Array.isArray(t))return[];let n=t.flatMap(e=>typeof e==`string`?[r(o,e)]:[]);return n.length===0?[]:[{pattern:e,targets:n}]})}catch{return[]}}function B(e,t){let n=e.indexOf(`*`);if(n===-1)return e===t?``:null;let r=e.slice(0,n),i=e.slice(n+1);return!t.startsWith(r)||!t.endsWith(i)?null:t.slice(r.length,t.length-i.length)}function V(e,t){let r=e.replace(`*`,t),i=H(r);if(i!==null)return i;for(let e of j){let t=H(`${r}${e}`);if(t!==null)return t}for(let e of j){let t=H(n(r,`index${e}`));if(t!==null)return t}return null}function H(e){return o(e)?e:null}function U(e){return!(e.startsWith(`.`)||e.startsWith(`/`)||/^[A-Za-z]:[\\/]/.test(e)||/^(?:node|data|file):/.test(e)||e.startsWith(`@/`))}function W(e){return e===`experimental-ash`||e.startsWith(`experimental-ash/`)}function G(e){return e.replaceAll(`\\`,`/`).includes(`/node_modules/`)}function K(e,t){let n=r(e),a=r(t);return n===a||n.startsWith(`${a}${i}`)}function q(e){let r=t(e);for(;;){if(o(n(r,`package.json`)))return r;let i=t(r);if(i===r)throw Error(`Failed to resolve the authored package root for "${e}".`);r=i}}export{S as a,_ as c,d,v as f,w as i,g as l,O as n,h as o,f as p,C as r,p as s,N as t,m as u};