@mnci/az-durable 0.1.0

package/dist/src/activity.d.ts

@@ -0,0 +1,92 @@
+import type { InvocationContext } from '@azure/functions';
+import type { OrchestrationContext, RetryOptions, Task } from 'durable-functions';
+import type { TypedActivity, TypedTask } from './types';
+/**
+ * Registers an activity and remembers its input and output types.
+ *
+ * @remarks
+ * **Do not annotate `handler` as `ActivityHandler`.** That type is an alias for
+ * `FunctionHandler`, which the SDK declares as
+ * `(triggerInput: any, context: InvocationContext) => FunctionResult<any>` — so
+ * annotating it discards the very signature this function exists to capture and
+ * silently reduces the activity to `any` in and `any` out. The same applies to
+ * any middleware wrapper typed `(h: ActivityHandler) => ActivityHandler`; make
+ * such wrappers generic instead. Both traps are lintable — see the
+ * `no-untyped-activity-handler` rule.
+ *
+ * `TOutput` is wrapped in `Awaited` so an `async` handler contributes its
+ * resolved type rather than a `Promise`.
+ *
+ * @param name - The activity name, a literal. Never derived from a variable or
+ * file name: it is baked into orchestration history, so a rename breaks every
+ * in-flight instance.
+ * @param handler - The activity implementation.
+ * @returns The activity, carrying its input and output types.
+ * @throws Error when `name` is already registered.
+ * @typeParam TInput - The JSON-serialisable input.
+ * @typeParam TOutput - The handler's return type, awaited.
+ */
+export declare function defineActivity<TInput, TOutput>(name: string, handler: (input: TInput, context: InvocationContext) => TOutput | Promise<TOutput>): TypedActivity<TInput, Awaited<TOutput>>;
+/**
+ * Schedules an activity without yielding it, for fan-out.
+ *
+ * @remarks
+ * The single place in this package that schedules an activity. `callActivity`
+ * is implemented in terms of it, so there is exactly one line to audit against
+ * an SDK change.
+ *
+ * **Scheduled through `context`, not through `activity.registered`,** and the
+ * two are equivalent — verified in the SDK source rather than assumed:
+ *
+ * ```
+ * registered(input)             -> new AtomicTask(false, new CallActivityAction(name, input))
+ * context.df.callActivity(...)  -> new AtomicTask(false, new CallActivityAction(name, input))
+ * ```
+ *
+ * `RegisteredActivityTask` is an `AtomicTask` subclass that only ADDS
+ * `withRetry`; the retry paths are identical too, both producing
+ * `RetryableTask(AtomicTask(CallActivityWithRetryAction(...)))`. The action is
+ * what enters orchestration history, so replay is unaffected.
+ *
+ * Routing through `context` is what makes {@link runWorkflow} possible without
+ * reading `task.action.functionName` — an undocumented internal the package's
+ * non-goals forbid depending on. It also makes every helper here uniformly
+ * context-first.
+ *
+ * @param context - The orchestration context.
+ * @param activity - The activity to schedule.
+ * @param input - The input, checked against the activity's declared type.
+ * @param retry - Optional retry policy.
+ * @returns A scheduled task, for `all`/`any`.
+ * @throws Never - scheduling is synchronous and cannot fail here.
+ * @typeParam TInput - The activity's input type.
+ * @typeParam TOutput - The activity's output type.
+ */
+export declare function activityTask<TInput, TOutput>(context: OrchestrationContext, activity: TypedActivity<TInput, TOutput>, input: TInput, retry?: RetryOptions): TypedTask<TOutput>;
+/**
+ * Calls an activity and returns its typed result.
+ *
+ * @remarks
+ * **Must be invoked with `yield*`, not `yield`.** The delegation is what carries
+ * the type: `yield*` returns this generator's `TReturn`, which is per-call
+ * generic, whereas a generator's `TNext` is shared by every `yield` and so can
+ * never be typed per call. A bare `yield` is a compile error rather than a
+ * silent `any` — `callActivity` returns a `Generator`, and yielding one where a
+ * `Task` is expected does not typecheck — but the error message is obscure, so
+ * prefer the lint rule's.
+ *
+ * Determinism is unaffected. The task yielded up to the Durable driver is the
+ * identical object a hand-written call would yield, so replay history and
+ * in-flight instances are untouched. This is a type-level change only.
+ *
+ * @param context - The orchestration context.
+ * @param activity - The activity to call.
+ * @param input - The input, checked against the activity's declared type.
+ * @param retry - Optional retry policy.
+ * @returns A generator to delegate to; its return value is the activity output.
+ * @throws Whatever the activity threw, once the driver resumes with a failure.
+ * @typeParam TInput - The activity's input type.
+ * @typeParam TOutput - The activity's output type.
+ */
+export declare function callActivity<TInput, TOutput>(context: OrchestrationContext, activity: TypedActivity<TInput, TOutput>, input: TInput, retry?: RetryOptions): Generator<Task, TOutput, unknown>;
+//# sourceMappingURL=activity.d.ts.map

package/dist/src/client.d.ts

@@ -0,0 +1,23 @@
+import type { DurableClient } from 'durable-functions';
+import type { TypedOrchestration } from './types';
+/**
+ * Starts an orchestration with an input checked against its declared type.
+ *
+ * @remarks
+ * `DurableClient.startNew` takes the orchestration **name** and an options
+ * object carrying `input`, both untyped. This narrows the pair so a caller
+ * cannot start an orchestration with the wrong payload shape.
+ *
+ * @param client - The Durable client, from `df.getClient(context)`.
+ * @param orchestration - The orchestration to start.
+ * @param input - The input, checked against its declared type.
+ * @param options - Optional instance id.
+ * @returns The new instance id.
+ * @throws Propagates whatever the client throws.
+ * @typeParam TInput - The orchestration's input type.
+ * @typeParam TOutput - The orchestration's output type, unused at runtime.
+ */
+export declare function startOrchestration<TInput, TOutput>(client: DurableClient, orchestration: TypedOrchestration<TInput, TOutput>, input: TInput, options?: {
+    instanceId?: string;
+}): Promise<string>;
+//# sourceMappingURL=client.d.ts.map

package/dist/src/eslint-plugin.d.ts

@@ -0,0 +1,46 @@
+import type { Rule } from './rules/shared';
+export type { Rule } from './rules/shared';
+/**
+ * Every rule this plugin ships, by name.
+ *
+ * @remarks
+ * The keys are the names a config writes after the `az-durable/` prefix, so
+ * renaming one is a breaking change for any consumer's config.
+ */
+export declare const rules: Record<string, Rule>;
+/**
+ * The plugin object, for a flat config's `plugins` map.
+ *
+ * @remarks
+ * Shipped from a separate entry point so lint rules are never a runtime import
+ * of the wrapper itself.
+ */
+export declare const plugin: {
+    rules: Record<string, Rule>;
+};
+/**
+ * The recommended rule set.
+ *
+ * @remarks
+ * Two errors and one warning, and the split is deliberate.
+ * `no-nondeterministic-orchestrator` and `no-untyped-activity-handler` catch
+ * failures nothing else does — silent replay corruption, and a type collapse
+ * TypeScript accepts as legal. `require-yield-star` is a warning because the
+ * compiler already rejects the code it flags; it only improves the message.
+ */
+export declare const recommended: {
+    readonly plugins: {
+        readonly 'az-durable': {
+            rules: Record<string, Rule>;
+        };
+    };
+    readonly rules: {
+        readonly 'az-durable/no-nondeterministic-orchestrator': "error";
+        readonly 'az-durable/no-untyped-activity-handler': "error";
+        readonly 'az-durable/require-yield-star': "warn";
+    };
+};
+export { noNondeterministicOrchestrator } from './rules/noNondeterministicOrchestrator';
+export { requireYieldStar } from './rules/requireYieldStar';
+export { noUntypedActivityHandler } from './rules/noUntypedActivityHandler';
+//# sourceMappingURL=eslint-plugin.d.ts.map

package/dist/src/events.d.ts

@@ -0,0 +1,81 @@
+import type { DurableClient, OrchestrationContext, Task } from 'durable-functions';
+import type { TypedTask } from './types';
+/**
+ * An external event name with its payload type attached.
+ *
+ * @remarks
+ * `__payload` is phantom — never assigned, never read. Event names, like
+ * activity names, are matched as strings by the runtime and must stay explicit
+ * literals.
+ *
+ * @typeParam TPayload - The JSON-serialisable payload the event carries.
+ */
+export interface EventRef<TPayload> {
+    /** The event name, verbatim. */
+    readonly name: string;
+    /** Phantom. Never assigned. Carries `TPayload`. */
+    readonly __payload?: () => TPayload;
+}
+/**
+ * Declares an external event and its payload type.
+ *
+ * @remarks
+ * Deliberately does not register anything — external events have no
+ * registration step in Durable Functions. This exists only to pair a name with
+ * a payload type so the waiter and the raiser cannot disagree.
+ *
+ * @param name - The event name, a literal.
+ * @returns The event reference.
+ * @throws Never - constructs an object.
+ * @typeParam TPayload - The payload type.
+ */
+export declare function defineEvent<TPayload>(name: string): EventRef<TPayload>;
+/**
+ * Waits for an external event and returns its typed payload.
+ *
+ * @remarks
+ * **Must be invoked with `yield *`.**
+ *
+ * @param context - The orchestration context.
+ * @param event - The event to wait for.
+ * @returns A generator whose return value is the event payload.
+ * @throws Never - resolves when the event arrives.
+ * @typeParam TPayload - The payload type.
+ */
+export declare function waitForEvent<TPayload>(context: OrchestrationContext, event: EventRef<TPayload>): Generator<Task, TPayload, unknown>;
+/**
+ * Schedules a wait for an external event, without yielding it.
+ *
+ * @remarks
+ * The task form of {@link waitForEvent}, and the reason it exists is a gap the
+ * reconstructed workflows found: `any` and `all` take `TypedTask`s, so with
+ * only the generator form the single most common Durable Functions pattern —
+ * **wait for human approval, or time out** — could not be expressed at all.
+ *
+ * Pair it with {@link timerTask} and hand both to `any`.
+ *
+ * @param context - The orchestration context.
+ * @param event - The event to wait for.
+ * @returns A task carrying the event's payload type.
+ * @throws Never - scheduling only.
+ * @typeParam TPayload - The payload type.
+ */
+export declare function eventTask<TPayload>(context: OrchestrationContext, event: EventRef<TPayload>): TypedTask<TPayload>;
+/**
+ * Raises an external event to a waiting instance, with a checked payload.
+ *
+ * @remarks
+ * The client half of {@link waitForEvent}. Pairing both sides through the same
+ * `EventRef` is what stops the raiser and the waiter disagreeing about the
+ * payload shape — the SDK types `eventData` as `unknown`, so nothing else would.
+ *
+ * @param client - The Durable client.
+ * @param instanceId - The instance to signal.
+ * @param event - The event being raised.
+ * @param payload - The payload, checked against the event's declared type.
+ * @returns A promise resolving when the event is enqueued.
+ * @throws Propagates whatever the client throws.
+ * @typeParam TPayload - The payload type.
+ */
+export declare function raiseEvent<TPayload>(client: DurableClient, instanceId: string, event: EventRef<TPayload>, payload: TPayload): Promise<void>;
+//# sourceMappingURL=events.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export type { TypedActivity, TypedOrchestration, TypedTask, TypedTimerTask } from './types';
+export { defineActivity, activityTask, callActivity } from './activity';
+export { defineOrchestration, callSubOrchestration, subOrchestrationTask } from './orchestration';
+export type { DefineOrchestrationOptions, OrchestrationSelf } from './orchestration';
+export { startOrchestration } from './client';
+export { retryPolicy } from './retry';
+export type { RetryPolicy } from './retry';
+export { all, any, resultOf } from './parallel';
+export type { TaskOutputs } from './parallel';
+export { defineEvent, waitForEvent, eventTask, raiseEvent } from './events';
+export type { EventRef } from './events';
+export { now, sleepUntil, sleepFor, timerTask, timerTaskUntil } from './time';
+export { defineStatuses, setStatus } from './status';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/orchestration.d.ts

@@ -0,0 +1,117 @@
+import type { OrchestrationContext, RetryOptions, Task } from 'durable-functions';
+import type { TypedOrchestration, TypedTask } from './types';
+/**
+ * The orchestration's handle on itself, handed to its own handler.
+ *
+ * @remarks
+ * Exists so `continueAsNew` can be typed. See the member for why it cannot be
+ * a free function.
+ *
+ * @typeParam TInput - This orchestration's input type.
+ */
+export interface OrchestrationSelf<TInput> {
+    /** The orchestration's own registered name. */
+    readonly name: string;
+    /**
+     * Restarts this orchestration with fresh input, discarding its history.
+     *
+     * @remarks
+     * Handed to the handler rather than exported as a free function, and that is
+     * the whole design: `continueAsNew` restarts **this** orchestration, so its
+     * argument must be this orchestration's own `TInput`. A free
+     * `continueAsNew(context, input)` could only be generic on a type nothing
+     * constrains, so it would accept any shape at all — precisely the unchecked
+     * cast this package exists to remove. Referring to the orchestration
+     * constant from inside its own handler is not an option either: it is not
+     * initialised yet.
+     *
+     * The call does not by itself end the generator. Return immediately after
+     * it, as the SDK requires; anything scheduled afterwards is discarded when
+     * the instance restarts.
+     */
+    readonly continueAsNew: (input: TInput) => void;
+}
+/**
+ * Options accepted by {@link defineOrchestration}.
+ *
+ * @remarks
+ * Only `parse` for now. Kept as an options object rather than a positional
+ * argument so a later addition does not change the call signature of every
+ * existing `defineOrchestration` call.
+ *
+ * @typeParam TInput - The orchestration's input type, which `parse` produces.
+ */
+export interface DefineOrchestrationOptions<TInput> {
+    /**
+     * Validates and narrows the raw input before the handler sees it.
+     *
+     * @remarks
+     * Optional, and worth using. `context.df.getInput<T>()` is an **unchecked
+     * cast** — `T` is a claim the SDK never verifies. That matters more here than
+     * in ordinary code because orchestration input comes back out of the task hub:
+     * an instance started by yesterday's deploy resumes against today's code, so a
+     * shape change between deploys surfaces as a silently wrong object rather than
+     * an error. A `parse` makes the claim real at the boundary.
+     */
+    readonly parse?: (raw: unknown) => TInput;
+}
+/**
+ * Registers an orchestration, handing the handler its deserialised input.
+ *
+ * @remarks
+ * The SDK's `OrchestrationHandler` takes **only** `context` — there is no input
+ * parameter — so this wrapper calls `getInput` itself and passes the result as a
+ * second argument. That is why consumers never write
+ * `context.df.getInput() as SomeType`.
+ *
+ * @param name - The orchestration name, a literal. Baked into history; never derive it.
+ * @param handler - The orchestration generator, receiving context and input.
+ * @param options - Optional input validation. See {@link DefineOrchestrationOptions}.
+ * @returns The orchestration, carrying its input and output types.
+ * @throws Error when `name` is already registered.
+ * @typeParam TInput - The JSON-serialisable input.
+ * @typeParam TOutput - The value the orchestration returns.
+ */
+export declare function defineOrchestration<TInput, TOutput>(name: string, handler: (context: OrchestrationContext, input: TInput, self: OrchestrationSelf<TInput>) => Generator<Task, TOutput, unknown>, options?: DefineOrchestrationOptions<TInput>): TypedOrchestration<TInput, TOutput>;
+/**
+ * Calls a sub-orchestration and returns its typed result.
+ *
+ * @remarks
+ * **Must be invoked with `yield*`.** See `callActivity` for why delegation is
+ * what carries the type.
+ *
+ * @param orchestration - The sub-orchestration to call.
+ * @param input - The input, checked against its declared type.
+ * @param options - Optional instance id and retry policy.
+ * @returns A generator to delegate to; its return value is the sub-orchestration output.
+ * @throws Whatever the sub-orchestration threw, once the driver resumes with a failure.
+ * @typeParam TInput - The sub-orchestration's input type.
+ * @typeParam TOutput - The sub-orchestration's output type.
+ */
+export declare function callSubOrchestration<TInput, TOutput>(context: OrchestrationContext, orchestration: TypedOrchestration<TInput, TOutput>, input: TInput, options?: {
+    instanceId?: string;
+    retry?: RetryOptions;
+}): Generator<Task, TOutput, unknown>;
+/**
+ * Schedules a sub-orchestration without yielding it.
+ *
+ * @remarks
+ * The task form of {@link callSubOrchestration}, so several sub-orchestrations
+ * can run concurrently through `all`. Fanning out over sub-orchestrations is
+ * the standard way to bound a large batch — each child gets its own history,
+ * so the parent's history does not grow with the batch size.
+ *
+ * @param context - The orchestration context.
+ * @param orchestration - The sub-orchestration to schedule.
+ * @param input - Its input, checked against its declared type.
+ * @param options - Optional fixed instance id and retry policy.
+ * @returns A task carrying the sub-orchestration's output type.
+ * @throws Never - scheduling only.
+ * @typeParam TInput - The sub-orchestration's input type.
+ * @typeParam TOutput - The sub-orchestration's output type.
+ */
+export declare function subOrchestrationTask<TInput, TOutput>(context: OrchestrationContext, orchestration: TypedOrchestration<TInput, TOutput>, input: TInput, options?: {
+    instanceId?: string;
+    retry?: RetryOptions;
+}): TypedTask<TOutput>;
+//# sourceMappingURL=orchestration.d.ts.map

package/dist/src/parallel.d.ts

@@ -0,0 +1,71 @@
+import type { OrchestrationContext, Task } from 'durable-functions';
+import type { TypedTask } from './types';
+/**
+ * The outputs of a tuple of tasks, in the same positions.
+ *
+ * @remarks
+ * Position preservation is the whole value: without it a `[string, number]`
+ * fan-out degrades to `(string | number)[]` and every destructured binding
+ * needs a cast, which is what the package exists to remove. `-readonly` strips
+ * the modifier that `readonly [...T]` introduces, so the result is an ordinary
+ * mutable tuple.
+ *
+ * @typeParam T - The tuple of tasks.
+ */
+export type TaskOutputs<T extends readonly TypedTask<unknown>[]> = {
+    -readonly [K in keyof T]: T[K] extends TypedTask<infer O> ? O : never;
+};
+/**
+ * Waits for every task, preserving tuple positions.
+ *
+ * @remarks
+ * **Must be invoked with `yield *`.** Takes `context` because `Task.all` is an
+ * instance member of `context.df`, not a static — the build plan's
+ * context-free signature cannot reach it.
+ *
+ * @param context - The orchestration context.
+ * @param tasks - The scheduled tasks, as a tuple.
+ * @returns A generator whose return value is the outputs, in input order.
+ * @throws `AggregatedError` when any task failed, matching the SDK.
+ * @typeParam T - The tuple of tasks.
+ */
+export declare function all<T extends readonly TypedTask<unknown>[]>(context: OrchestrationContext, tasks: readonly [...T]): Generator<Task, TaskOutputs<T>, unknown>;
+/**
+ * Waits for the first task to complete and returns **which one won**.
+ *
+ * @remarks
+ * Returns the winning task, not its result, because that is what the SDK does:
+ * `Task.any` is documented as returning "the first Task from tasks to
+ * complete", and the SDK's own example compares it by identity
+ * (`if (winner === otherTask)`). The build plan's signature returned the
+ * output type instead, which would hand back a `Task` at runtime while the
+ * compiler believed it was the output — the exact class of silent mistyping
+ * this package exists to prevent.
+ *
+ * The winner is mapped back to the `TypedTask` the caller passed, so `===`
+ * against the original works. Read its value with {@link resultOf}.
+ *
+ * **Must be invoked with `yield *`.**
+ *
+ * @param context - The orchestration context.
+ * @param tasks - The scheduled tasks.
+ * @returns A generator whose return value is the winning task.
+ * @throws Error when the SDK returns a task that was not one of the inputs.
+ * @typeParam T - The tuple of tasks.
+ */
+export declare function any<T extends readonly TypedTask<unknown>[]>(context: OrchestrationContext, tasks: readonly [...T]): Generator<Task, T[number], unknown>;
+/**
+ * Reads a completed task's result, typed.
+ *
+ * @remarks
+ * `Task.result` is declared `unknown` by the SDK. This applies the output type
+ * the `TypedTask` was carrying all along. Only meaningful after the task has
+ * completed — typically on the winner from {@link any}.
+ *
+ * @param task - A completed task.
+ * @returns Its result, typed as the task's output.
+ * @throws Never - reads a property.
+ * @typeParam TOutput - The task's output type.
+ */
+export declare function resultOf<TOutput>(task: TypedTask<TOutput>): TOutput;
+//# sourceMappingURL=parallel.d.ts.map

package/dist/src/registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Duplicate-name detection for activities and orchestrations.
+ *
+ * @remarks
+ * Activity and orchestration names are **global to the Function App** and are
+ * baked into orchestration history in the task hub. Two features registering
+ * the same string is a silent misbinding: the second registration wins, and the
+ * first feature's calls quietly execute the wrong handler. Nothing surfaces
+ * until replay, by which point the history already refers to the wrong thing.
+ *
+ * Failing loudly at startup is strictly better, so registration throws.
+ */
+/**
+ * Records a name, throwing if it was already taken.
+ *
+ * @remarks
+ * The error names **both** call sites when the stack makes them available. A
+ * bare "duplicate name" message sends the reader hunting through a Function App
+ * for the other registration, which is the slowest part of fixing this.
+ *
+ * @param kind - `activity` or `orchestration`, for the message.
+ * @param name - The name being registered.
+ * @returns Nothing.
+ * @throws Error when `name` has already been registered.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function claimName(kind: 'activity' | 'orchestration', name: string): void;
+/**
+ * Clears the registry. Test-only.
+ *
+ * @remarks
+ * Module state persists across tests in the same worker, so without this a
+ * second test registering the same name fails for the wrong reason. Not
+ * exported from the package entry point — it is only reachable inside the
+ * package's own tests.
+ *
+ * @param None - this function takes no parameters.
+ * @returns Nothing.
+ * @throws Never - clears a map.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function resetRegistryForTests(): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/retry.d.ts

@@ -0,0 +1,45 @@
+import { RetryOptions } from 'durable-functions';
+/**
+ * A retry policy as a plain object.
+ *
+ * @remarks
+ * Exists because the SDK's `RetryOptions` is a **class** whose two required
+ * settings are constructor arguments and whose three optional ones are mutable
+ * properties. That shape cannot be written as an object literal, so without
+ * this every caller has to `new RetryOptions(1000, 3)` and then assign the rest
+ * — and discover that for themselves, since a literal fails with a `TS2739`
+ * naming three members it never mentions.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface RetryPolicy {
+    /** The first retry interval, in milliseconds. Must be greater than 0. */
+    readonly firstRetryIntervalInMilliseconds: number;
+    /** How many attempts to make in total, the first included. */
+    readonly maxNumberOfAttempts: number;
+    /** Multiplier applied to the interval after each attempt. Defaults to the SDK's. */
+    readonly backoffCoefficient?: number;
+    /** Ceiling on the interval between attempts, in milliseconds. */
+    readonly maxRetryIntervalInMilliseconds?: number;
+    /** Overall deadline for the retries, in milliseconds. */
+    readonly retryTimeoutInMilliseconds?: number;
+}
+/**
+ * Builds a real SDK `RetryOptions` from a plain object.
+ *
+ * @remarks
+ * Returns a genuine class instance rather than a structurally-similar literal,
+ * deliberately: handing `callActivityWithRetry` a plain object would depend on
+ * the SDK reading it structurally, which is undocumented and exactly the kind
+ * of internal this package refuses to rely on.
+ *
+ * Only the properties actually supplied are assigned, so the SDK's own
+ * defaults stand for the rest instead of being overwritten with `undefined`.
+ *
+ * @param policy - The retry settings.
+ * @returns An SDK `RetryOptions` instance.
+ * @throws Whatever the SDK constructor throws for an invalid interval.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function retryPolicy(policy: RetryPolicy): RetryOptions;
+//# sourceMappingURL=retry.d.ts.map

package/dist/src/rules/noNondeterministicOrchestrator.d.ts

@@ -0,0 +1,17 @@
+import { type Rule } from './shared';
+/**
+ * Flags non-deterministic operations inside an orchestration body.
+ *
+ * @remarks
+ * The highest-value rule in the package. Each of these returns a DIFFERENT
+ * value on every replay, and the failure is silent: the orchestration still
+ * completes, it just produces output that disagrees with its own history.
+ * Nothing in the runtime reports it.
+ *
+ * Every message names the replacement, because "this is non-deterministic" is
+ * only half of what a reader needs.
+ *
+ * Heuristic by design — see {@link isOrchestrationRegistration}.
+ */
+export declare const noNondeterministicOrchestrator: Rule;
+//# sourceMappingURL=noNondeterministicOrchestrator.d.ts.map

package/dist/src/rules/noUntypedActivityHandler.d.ts

@@ -0,0 +1,27 @@
+import type { Rule } from './shared';
+/**
+ * Flags annotations that collapse a typed handler back to `any`.
+ *
+ * @remarks
+ * **The rule that actually earns its keep**, because TypeScript cannot catch
+ * this: the annotation is legal, so nothing errors — the types simply stop
+ * meaning anything.
+ *
+ * `ActivityHandler` is an alias for `FunctionHandler`, which the SDK declares as
+ * `(triggerInput: any, context: InvocationContext) => FunctionResult<any>`. So
+ * annotating a handler with it discards the very signature `defineActivity`
+ * exists to capture, and the activity silently becomes `any` in, `any` out. The
+ * package then appears to work — every call compiles — while checking nothing.
+ *
+ * The second, nastier form is a middleware wrapper typed
+ * `(h: ActivityHandler) => ActivityHandler`. That collapses EVERY handler it
+ * wraps, so one `injectLogger` helper can quietly disable type safety across a
+ * whole Function App. The fix is to make the wrapper generic:
+ *
+ * ```ts
+ * const withLogging = <I, O>(h: (i: I, c: InvocationContext) => O) =>
+ *   (i: I, c: InvocationContext): O => { c.log('...'); return h(i, c) }
+ * ```
+ */
+export declare const noUntypedActivityHandler: Rule;
+//# sourceMappingURL=noUntypedActivityHandler.d.ts.map

package/dist/src/rules/requireYieldStar.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from './shared';
+/**
+ * Flags `yield callActivity(...)` where `yield *` is meant.
+ *
+ * @remarks
+ * **A convenience, not a safety net — and the build plan was wrong about this.**
+ * The plan described bare `yield` as compiling silently to `any`, "the
+ * difference between the package working and appearing to work". Measured
+ * against the real typings, it is a COMPILE ERROR in both registration paths:
+ * `TS2345` through `defineOrchestration` and `TS2322` through the SDK's own
+ * `OrchestrationHandler`, because these helpers return a `Generator` and
+ * yielding one where a `Task` is expected does not typecheck.
+ *
+ * The genuinely silent case is the RAW SDK — `yield context.df.callActivity(...)`
+ * returns `any` and compiles — which is the baseline this package replaces.
+ *
+ * So this rule earns its place only by reporting a clearer message than
+ * `TS2345` does. It is in `recommended` for that reason, not because anything
+ * depends on it.
+ */
+export declare const requireYieldStar: Rule;
+//# sourceMappingURL=requireYieldStar.d.ts.map