@btravstack/temporal-worker 0.15.0 → 0.17.0

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _btravstack_core = require("@btravstack/core");
 let _btravstack_di = require("@btravstack/di");
 let _btravstack_config = require("@btravstack/config");
-let _btravstack_core = require("@btravstack/core");
 let _temporal_contract_worker_activity = require("@temporal-contract/worker/activity");
 let _temporalio_common = require("@temporalio/common");
 let _temporalio_worker = require("@temporalio/worker");
@@ -9,47 +9,12 @@ let unthrown = require("unthrown");
 let _temporalio_activity = require("@temporalio/activity");
 //#region src/unit.ts
 /**
-* Where `activityUnits` leaves the forked context for the piece wrappers to
-* read. A symbol rather than a name: the middleware merges it into the context
-* every activity sees, and a string key would appear on the record an activity
-* written against the `{ inject, sync }` arm destructures.
-*/
-const UNIT_SCOPE = Symbol("@btravstack/temporal-worker/unit-scope");
-/**
-* The declared record, as a getter per name resolved on read out of the fork.
-* Neither writable nor configurable — an activity reads what the fork holds, and
-* cannot reshape the record under the next attempt. With no `unit.activity`
-* bound there is nothing to resolve from, so the record is empty whatever was
-* declared.
-*/
-const unitRecordOf = (forked, record) => {
-	const unit = {};
-	if (forked === void 0) return unit;
-	for (const [name, port] of Object.entries(record)) Object.defineProperty(unit, name, {
-		enumerable: true,
-		get: () => forked.get(port)
-	});
-	return unit;
-};
-/**
 * One entry of the activities record — a contract-global activity's own
 * implementation, or the record of them a workflow key carries — with its
 * piece's declared record put on `context.unit`. Applied once per piece as di
 * constructs it, so an attempt costs one record and one context object.
 */
-const withUnit = (record, entry) => {
-	const wrap = (implementation) => (helpers, input) => {
-		const { [UNIT_SCOPE]: forked, ...rest } = helpers.context ?? {};
-		return implementation({
-			...helpers,
-			context: {
-				...rest,
-				unit: unitRecordOf(forked, record)
-			}
-		}, input);
-	};
-	return typeof entry === "function" ? wrap(entry) : Object.fromEntries(Object.entries(entry).map(([name, implementation]) => [name, wrap(implementation)]));
-};
+const withUnit = (record, entry) => typeof entry === "function" ? (0, _btravstack_core.withUnitRecord)(record, entry) : Object.fromEntries(Object.entries(entry).map(([name, implementation]) => [name, (0, _btravstack_core.withUnitRecord)(record, implementation)]));
 //#endregion
 //#region src/workflow-activities.ts
 /** One id, declared once, so no contract instantiating it warns about a duplicate. */
@@ -99,13 +64,8 @@ const WORKFLOW_ACTIVITIES_PREFIX = "TemporalWorkflowActivities:";
 */
 const TemporalWorkflowActivities = (contract, key) => {
 	const port = class extends (0, _btravstack_di.Port)(`${WORKFLOW_ACTIVITIES_PREFIX}${key}`) {};
-	return (options) => {
-		const record = options.unit ?? {};
-		return Object.assign((0, _btravstack_di.Provider)(port)({
-			inject: options.inject,
-			sync: (services) => withUnit(record, options.sync(services))
-		}), { unit: record });
-	};
+	const mint = (0, _btravstack_core.mintPiece)(port, withUnit);
+	return (options) => mint(options);
 };
 //#endregion
 //#region src/activity-units.ts
@@ -118,9 +78,8 @@ const TemporalWorkflowActivities = (contract, key) => {
 * bound, `next()` runs unchanged, so the ambient `currentUnit()` record is what
 * an adapter reads.
 *
-* The forked context rides the invocation's context under {@link UNIT_SCOPE},
-* where each piece's own wrapper turns it into the typed `context.unit` record
-* that piece declared — the records live with the pieces, so a hand-composed
+* The forked context rides the invocation's context, where each piece's own
+* wrapper turns it into the typed `context.unit` record that piece declared — the records live with the pieces, so a hand-composed
 * `temporal()` gets them without threading a second option through the starter,
 * and the middleware never has to map Temporal's FLAT activity name back to the
 * workflow key its piece was minted under.
@@ -133,17 +92,19 @@ const TemporalWorkflowActivities = (contract, key) => {
 * No `Result`-unwrapping boundary, deliberately: `declareActivitiesHandler` owns
 * the mapping from a settled `Result` to an activity failure.
 */
-const activityUnits = (host, observers, unit) => (invocation, next) => {
-	const settle = (0, _btravstack_core.observe)(observers, {
+const activityUnits = (host, observers, unit) => (invocation, next) => (0, _btravstack_core.dispatchUnit)({
+	host,
+	observers,
+	operation: {
 		component: "temporal",
 		name: "attempt",
 		attributes: { activity: (0, _temporalio_activity.activityInfo)().activityType }
-	});
-	return host.run(metaFor(), (scope) => unit === void 0 ? next() : scope.fork(unit, [[ActivityInputPort, invocation.input]]).flatMap((forked) => next({ context: { [UNIT_SCOPE]: forked } }))).tap(() => settle({ outcome: "ok" })).tapFailure((failure) => settle({
-		outcome: "error",
-		cause: failure.tag === "Err" ? failure.error : failure.cause
-	}));
-};
+	},
+	meta: metaFor(),
+	unit,
+	seed: [ActivityInputPort, invocation.input],
+	next
+});
 /**
 * `UnitMeta.id` must be unique per unit, and a workflow id is **not** one: an
 * activity is retried under the same execution. A task token identifies one
@@ -151,7 +112,17 @@ const activityUnits = (host, observers, unit) => (invocation, next) => {
 *
 * The workflow id becomes the `traceId` — minted outside this process and steady
 * across every retry, so all attempts join up in a log. An activity with no
-* workflow falls back to the activity id.
+* workflow falls back to the activity id; `workflowExecution` is optional
+* because Temporal's own `Info` declares it so, "not set if the activity was
+* not started by a Workflow", which a worker polling a task queue never sees.
+*
+* **A REUSED workflow id merges its runs into one trace**, and that is the
+* trade rather than an oversight: Temporal allows an id again once the previous
+* execution closed, so `order-42` run twice is one `traceId` over two runs.
+* `runId` would separate them and is the wrong correlation for this transport —
+* server-minted, opaque, and not what an operator greps for. A deployment that
+* needs per-run traces gives its workflows unique ids, which is what a Schedule
+* already does.
 */
 const metaFor = () => {
 	const info = (0, _temporalio_activity.activityInfo)();
@@ -242,10 +213,7 @@ const temporal = (options) => {
 				})),
 				release: (connection) => connection.close().catch((cause) => heldByWorker(cause) ? void 0 : Promise.reject(cause))
 			}),
-			_btravstack_di.Provider.member(_btravstack_core.Observers)({
-				inject: {},
-				value: _btravstack_core.noObserver
-			}),
+			_btravstack_core.noObserverMember,
 			(0, _btravstack_di.Provider)(TemporalRuntime)({
 				inject: {
 					connection: TemporalConnection,
@@ -373,19 +341,7 @@ const TemporalModule = (name) => (options) => {
 * and two slices claiming one key are di's duplicate-provider defect at build.
 */
 const TemporalActivities = (contract) => {
-	const build = (0, _btravstack_di.Provider)(TemporalActivitiesPort);
-	const compose = (pieces) => build({
-		inject: Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(27), piece.port])),
-		sync: (services) => services
-	});
-	const whole = (options) => {
-		const record = options.unit ?? {};
-		return build({
-			inject: options.inject,
-			sync: (services) => Object.fromEntries(Object.entries(options.sync(services)).map(([key, entry]) => [key, withUnit(record, entry)]))
-		});
-	};
-	return ((first) => Array.isArray(first) ? compose(first) : whole(first));
+	return (0, _btravstack_core.composeByPrefix)(TemporalActivitiesPort, WORKFLOW_ACTIVITIES_PREFIX, withUnit);
 };
 //#endregion
 exports.ActivityInput = ActivityInput;

package/dist/index.d.cts

@@ -1,24 +1,10 @@
 import { ConfigInvalid, Env } from "@btravstack/config";
+import { AnyUnitModule, Refuse, Runtime, RuntimePort, UnitGate, UnitNeedsOf, UnitRecordOf } from "@btravstack/core";
 import { AnyModule, AnyPort, AnyProvider, Exportable, Module, NeedsGate, PortClassOf, PortInstance, Provider, Scope, ServiceOf } from "@btravstack/di";
 import { ContractDefinition } from "@temporal-contract/contract";
-import { Runtime, RuntimePort } from "@btravstack/core";
 import { DeclareActivitiesHandlerOptions, EmptyContext } from "@temporal-contract/worker/activity";
 import { Duration } from "@temporalio/common";
 import { NativeConnection, WorkflowBundleWithSourceMap } from "@temporalio/worker";
-//#region src/unit.d.ts
-/** What a bound unit module exports — the port instances an activity of that kind may read. */
-type UnitExportsOf<M> = M extends Module<infer X, never, unknown> ? X : never;
-/** The declared `unit:` record, as the services an activity reads off `context.unit`. */
-type UnitRecordOf<U extends Readonly<Record<string, AnyPort>>> = { readonly [N in keyof U]: ServiceOf<InstanceType<U[N]>>; };
-/**
- * A piece injecting a port the bound `unit.activity` module does not export.
- * `unknown` when every declared port is covered — including the empty case, so
- * a worker whose pieces declare no `unit:` is gated on nothing.
- */
-type UnitGate<Unit, Declared> = [Exclude<NonNullable<Declared>, UnitExportsOf<Unit>>] extends [never] ? unknown : {
-  readonly "UNIT DOES NOT PROVIDE — a piece injects a port the bound unit module does not export": Exclude<NonNullable<Declared>, UnitExportsOf<Unit>>;
-};
-//#endregion
 //#region src/workflow-activities.d.ts
 /**
  * `ActivitiesOf<C, …>` is a `NoInfer`-wrapped conditional TypeScript refuses to
@@ -76,8 +62,6 @@ type WorkflowActivitiesPortOf<C extends ContractDefinition, K extends Activities
 /** What a minted piece returns. */
 type MintedActivities<C extends ContractDefinition, K extends ActivitiesKeyOf<C>, N, U extends Readonly<Record<string, AnyPort>>> = Provider<InstanceType<WorkflowActivitiesPortOf<C, K>>, never, N> & {
   readonly port: WorkflowActivitiesPortOf<C, K>;
-  /** The declared `unit:` record, which the wrapper resolves against. */
-  readonly unit: U;
   /** Phantom: the ports this piece injects, which the root's `unit.activity` must export. */
   readonly _declared?: InstanceType<U[keyof U]>;
 };
@@ -167,22 +151,8 @@ export declare class TemporalUnreachable extends TemporalUnreachable_base<{
 }
 /** The runtime's port: what `temporal()` provides, and what the module `start` boots must export. */
 export declare class TemporalRuntime extends RuntimePort<Runtime<never, TemporalInfo>> {}
-/**
- * A module `unit.activity` may bind, as the upper bound `temporal()`
- * constrains its own `Unit` type parameter to. `Module`'s `_exports` channel
- * is contravariant, so `Exports = never` — never `unknown` — is what makes a
- * REAL module's own (necessarily narrower) export type assignable to this
- * bound: `(x: Concrete) => void` is assignable to `(x: never) => void`, not
- * to `(x: unknown) => void`.
- */
-type AnyUnitModule = Module<never, never, unknown>;
-/**
- * The needs a bound `unit.activity` module still owes, or `never` when none is
- * bound. `Scope` is excluded, since nothing can ever provide it — the same
- * exemption `NeedsGate` itself carries — and so is the activity input, which
- * the fork's own seed discharges.
- */
-type UnitNeedsOf<Unit> = Unit extends Module<never, never, infer N> ? Exclude<N, Scope | ActivityInputInstance> : never;
+/** The needs a bound `unit.activity` module still owes, less the input the fork's seed discharges. */
+type UnitNeedsOf$1<Unit> = UnitNeedsOf<Unit, ActivityInputInstance>;
 /**
  * The activity implementations `declareActivitiesHandler` takes for `C`.
  * `TContext` is what an implementation reads off `helpers.context` — left
@@ -250,11 +220,11 @@ type Provided = TemporalRuntime | TemporalConfig | TemporalConnection;
  * Each configuration field is pinned on its own: a pinned field reads nothing
  * from the environment, and a field left unpinned still does.
  */
-export declare const temporal: <C extends ContractDefinition, Unit extends AnyUnitModule | undefined = undefined>(options: TemporalOptions<C, Unit>) => Module<Provided, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf<Unit>>;
+export declare const temporal: <C extends ContractDefinition, Unit extends AnyUnitModule | undefined = undefined>(options: TemporalOptions<C, Unit>) => Module<Provided, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf$1<Unit>>;
 //#endregion
 //#region src/temporal-module.d.ts
 /** The starter's own module, as the sugar adds it to the application's imports. */
-type TemporalStarter<C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = Module<TemporalRuntime | TemporalConfig | TemporalConnection, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf<Unit>>;
+type TemporalStarter<C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = Module<TemporalRuntime | TemporalConfig | TemporalConnection, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf$1<Unit>>;
 /** The application's imports plus the starter — the tuple `Module(name)` is handed. */
 type Imports<I extends readonly AnyModule[], C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = readonly [...I, TemporalStarter<C, Unit>];
 /** The activities provider plus the application's own — the tuple `Module(name)` is handed. */
@@ -318,19 +288,6 @@ type KeyOfPiece<P> = P extends {
 } ? K : never;
 /** The record's top-level keys no piece in `T` covers. */
 type Uncovered<C extends ContractDefinition, T extends readonly PieceOf<C>[]> = Exclude<ActivitiesKeyOf<C>, KeyOfPiece<T[number]>>;
-/**
- * A refused array: as long as the array the caller wrote, its head the caller's
- * own elements — which match — and its LAST element the marker paired with what
- * is wrong.
- *
- * TypeScript compares two equal-length tuples element by element, so the extra
- * diagnostic it reports lands on the trailing element and carries both the
- * sentence and the missing key. A fixed two-element tuple named the key only
- * when the array happened to be two elements long; every other arity was a
- * length mismatch, and the developer diffed the contract against the array by
- * hand.
- */
-type Refuse<T extends readonly unknown[], Marker extends string, Detail> = T extends readonly [...infer Head, unknown] ? readonly [...Head, readonly [Marker, Detail]] : readonly [readonly [Marker, Detail]];
 /**
  * The record arm: the whole activities record from one `sync`, with one `unit:`
  * record shared by every entry in it.

package/dist/index.d.mts

@@ -1,24 +1,10 @@
+import { AnyUnitModule, Refuse, Runtime, RuntimePort, UnitGate, UnitNeedsOf, UnitRecordOf } from "@btravstack/core";
 import { AnyModule, AnyPort, AnyProvider, Exportable, Module, NeedsGate, PortClassOf, PortInstance, Provider, Scope, ServiceOf } from "@btravstack/di";
 import { ConfigInvalid, Env } from "@btravstack/config";
-import { Runtime, RuntimePort } from "@btravstack/core";
 import { DeclareActivitiesHandlerOptions, EmptyContext } from "@temporal-contract/worker/activity";
 import { Duration } from "@temporalio/common";
 import { NativeConnection, Worker, WorkflowBundleWithSourceMap } from "@temporalio/worker";
 import { ContractDefinition } from "@temporal-contract/contract";
-//#region src/unit.d.ts
-/** What a bound unit module exports — the port instances an activity of that kind may read. */
-type UnitExportsOf<M> = M extends Module<infer X, never, unknown> ? X : never;
-/** The declared `unit:` record, as the services an activity reads off `context.unit`. */
-type UnitRecordOf<U extends Readonly<Record<string, AnyPort>>> = { readonly [N in keyof U]: ServiceOf<InstanceType<U[N]>>; };
-/**
- * A piece injecting a port the bound `unit.activity` module does not export.
- * `unknown` when every declared port is covered — including the empty case, so
- * a worker whose pieces declare no `unit:` is gated on nothing.
- */
-type UnitGate<Unit, Declared> = [Exclude<NonNullable<Declared>, UnitExportsOf<Unit>>] extends [never] ? unknown : {
-  readonly "UNIT DOES NOT PROVIDE — a piece injects a port the bound unit module does not export": Exclude<NonNullable<Declared>, UnitExportsOf<Unit>>;
-};
-//#endregion
 //#region src/workflow-activities.d.ts
 /**
  * `ActivitiesOf<C, …>` is a `NoInfer`-wrapped conditional TypeScript refuses to
@@ -76,8 +62,6 @@ type WorkflowActivitiesPortOf<C extends ContractDefinition, K extends Activities
 /** What a minted piece returns. */
 type MintedActivities<C extends ContractDefinition, K extends ActivitiesKeyOf<C>, N, U extends Readonly<Record<string, AnyPort>>> = Provider<InstanceType<WorkflowActivitiesPortOf<C, K>>, never, N> & {
   readonly port: WorkflowActivitiesPortOf<C, K>;
-  /** The declared `unit:` record, which the wrapper resolves against. */
-  readonly unit: U;
   /** Phantom: the ports this piece injects, which the root's `unit.activity` must export. */
   readonly _declared?: InstanceType<U[keyof U]>;
 };
@@ -167,22 +151,8 @@ export declare class TemporalUnreachable extends TemporalUnreachable_base<{
 }
 /** The runtime's port: what `temporal()` provides, and what the module `start` boots must export. */
 export declare class TemporalRuntime extends RuntimePort<Runtime<never, TemporalInfo>> {}
-/**
- * A module `unit.activity` may bind, as the upper bound `temporal()`
- * constrains its own `Unit` type parameter to. `Module`'s `_exports` channel
- * is contravariant, so `Exports = never` — never `unknown` — is what makes a
- * REAL module's own (necessarily narrower) export type assignable to this
- * bound: `(x: Concrete) => void` is assignable to `(x: never) => void`, not
- * to `(x: unknown) => void`.
- */
-type AnyUnitModule = Module<never, never, unknown>;
-/**
- * The needs a bound `unit.activity` module still owes, or `never` when none is
- * bound. `Scope` is excluded, since nothing can ever provide it — the same
- * exemption `NeedsGate` itself carries — and so is the activity input, which
- * the fork's own seed discharges.
- */
-type UnitNeedsOf<Unit> = Unit extends Module<never, never, infer N> ? Exclude<N, Scope | ActivityInputInstance> : never;
+/** The needs a bound `unit.activity` module still owes, less the input the fork's seed discharges. */
+type UnitNeedsOf$1<Unit> = UnitNeedsOf<Unit, ActivityInputInstance>;
 /**
  * The activity implementations `declareActivitiesHandler` takes for `C`.
  * `TContext` is what an implementation reads off `helpers.context` — left
@@ -250,11 +220,11 @@ type Provided = TemporalRuntime | TemporalConfig | TemporalConnection;
  * Each configuration field is pinned on its own: a pinned field reads nothing
  * from the environment, and a field left unpinned still does.
  */
-export declare const temporal: <C extends ContractDefinition, Unit extends AnyUnitModule | undefined = undefined>(options: TemporalOptions<C, Unit>) => Module<Provided, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf<Unit>>;
+export declare const temporal: <C extends ContractDefinition, Unit extends AnyUnitModule | undefined = undefined>(options: TemporalOptions<C, Unit>) => Module<Provided, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf$1<Unit>>;
 //#endregion
 //#region src/temporal-module.d.ts
 /** The starter's own module, as the sugar adds it to the application's imports. */
-type TemporalStarter<C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = Module<TemporalRuntime | TemporalConfig | TemporalConnection, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf<Unit>>;
+type TemporalStarter<C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = Module<TemporalRuntime | TemporalConfig | TemporalConnection, ConfigInvalid | TemporalUnreachable, Env | Scope | ActivitiesInstanceOf<C> | UnitNeedsOf$1<Unit>>;
 /** The application's imports plus the starter — the tuple `Module(name)` is handed. */
 type Imports<I extends readonly AnyModule[], C extends ContractDefinition, Unit extends AnyUnitModule | undefined> = readonly [...I, TemporalStarter<C, Unit>];
 /** The activities provider plus the application's own — the tuple `Module(name)` is handed. */
@@ -318,19 +288,6 @@ type KeyOfPiece<P> = P extends {
 } ? K : never;
 /** The record's top-level keys no piece in `T` covers. */
 type Uncovered<C extends ContractDefinition, T extends readonly PieceOf<C>[]> = Exclude<ActivitiesKeyOf<C>, KeyOfPiece<T[number]>>;
-/**
- * A refused array: as long as the array the caller wrote, its head the caller's
- * own elements — which match — and its LAST element the marker paired with what
- * is wrong.
- *
- * TypeScript compares two equal-length tuples element by element, so the extra
- * diagnostic it reports lands on the trailing element and carries both the
- * sentence and the missing key. A fixed two-element tuple named the key only
- * when the array happened to be two elements long; every other arity was a
- * length mismatch, and the developer diffed the contract against the array by
- * hand.
- */
-type Refuse<T extends readonly unknown[], Marker extends string, Detail> = T extends readonly [...infer Head, unknown] ? readonly [...Head, readonly [Marker, Detail]] : readonly [readonly [Marker, Detail]];
 /**
  * The record arm: the whole activities record from one `sync`, with one `unit:`
  * record shared by every entry in it.

package/dist/index.mjs

@@ -1,6 +1,6 @@
+import { Observers, RuntimePort, RuntimeStartFailed, composeByPrefix, dispatchUnit, mintPiece, noObserverMember, releasedBy, withUnitRecord } from "@btravstack/core";
 import { Module, Port, Provider } from "@btravstack/di";
 import { Config, Env } from "@btravstack/config";
-import { Observers, RuntimePort, RuntimeStartFailed, noObserver, observe, releasedBy } from "@btravstack/core";
 import { declareActivitiesHandler } from "@temporal-contract/worker/activity";
 import { msToNumber } from "@temporalio/common";
 import { NativeConnection, Worker } from "@temporalio/worker";
@@ -8,47 +8,12 @@ import { Ok, OkAsync, TaggedError, fromPromise, fromSafePromise, fromThrowable }
 import { activityInfo } from "@temporalio/activity";
 //#region src/unit.ts
 /**
-* Where `activityUnits` leaves the forked context for the piece wrappers to
-* read. A symbol rather than a name: the middleware merges it into the context
-* every activity sees, and a string key would appear on the record an activity
-* written against the `{ inject, sync }` arm destructures.
-*/
-const UNIT_SCOPE = Symbol("@btravstack/temporal-worker/unit-scope");
-/**
-* The declared record, as a getter per name resolved on read out of the fork.
-* Neither writable nor configurable — an activity reads what the fork holds, and
-* cannot reshape the record under the next attempt. With no `unit.activity`
-* bound there is nothing to resolve from, so the record is empty whatever was
-* declared.
-*/
-const unitRecordOf = (forked, record) => {
-	const unit = {};
-	if (forked === void 0) return unit;
-	for (const [name, port] of Object.entries(record)) Object.defineProperty(unit, name, {
-		enumerable: true,
-		get: () => forked.get(port)
-	});
-	return unit;
-};
-/**
 * One entry of the activities record — a contract-global activity's own
 * implementation, or the record of them a workflow key carries — with its
 * piece's declared record put on `context.unit`. Applied once per piece as di
 * constructs it, so an attempt costs one record and one context object.
 */
-const withUnit = (record, entry) => {
-	const wrap = (implementation) => (helpers, input) => {
-		const { [UNIT_SCOPE]: forked, ...rest } = helpers.context ?? {};
-		return implementation({
-			...helpers,
-			context: {
-				...rest,
-				unit: unitRecordOf(forked, record)
-			}
-		}, input);
-	};
-	return typeof entry === "function" ? wrap(entry) : Object.fromEntries(Object.entries(entry).map(([name, implementation]) => [name, wrap(implementation)]));
-};
+const withUnit = (record, entry) => typeof entry === "function" ? withUnitRecord(record, entry) : Object.fromEntries(Object.entries(entry).map(([name, implementation]) => [name, withUnitRecord(record, implementation)]));
 //#endregion
 //#region src/workflow-activities.ts
 /** One id, declared once, so no contract instantiating it warns about a duplicate. */
@@ -98,13 +63,8 @@ const WORKFLOW_ACTIVITIES_PREFIX = "TemporalWorkflowActivities:";
 */
 const TemporalWorkflowActivities = (contract, key) => {
 	const port = class extends Port(`${WORKFLOW_ACTIVITIES_PREFIX}${key}`) {};
-	return (options) => {
-		const record = options.unit ?? {};
-		return Object.assign(Provider(port)({
-			inject: options.inject,
-			sync: (services) => withUnit(record, options.sync(services))
-		}), { unit: record });
-	};
+	const mint = mintPiece(port, withUnit);
+	return (options) => mint(options);
 };
 //#endregion
 //#region src/activity-units.ts
@@ -117,9 +77,8 @@ const TemporalWorkflowActivities = (contract, key) => {
 * bound, `next()` runs unchanged, so the ambient `currentUnit()` record is what
 * an adapter reads.
 *
-* The forked context rides the invocation's context under {@link UNIT_SCOPE},
-* where each piece's own wrapper turns it into the typed `context.unit` record
-* that piece declared — the records live with the pieces, so a hand-composed
+* The forked context rides the invocation's context, where each piece's own
+* wrapper turns it into the typed `context.unit` record that piece declared — the records live with the pieces, so a hand-composed
 * `temporal()` gets them without threading a second option through the starter,
 * and the middleware never has to map Temporal's FLAT activity name back to the
 * workflow key its piece was minted under.
@@ -132,17 +91,19 @@ const TemporalWorkflowActivities = (contract, key) => {
 * No `Result`-unwrapping boundary, deliberately: `declareActivitiesHandler` owns
 * the mapping from a settled `Result` to an activity failure.
 */
-const activityUnits = (host, observers, unit) => (invocation, next) => {
-	const settle = observe(observers, {
+const activityUnits = (host, observers, unit) => (invocation, next) => dispatchUnit({
+	host,
+	observers,
+	operation: {
 		component: "temporal",
 		name: "attempt",
 		attributes: { activity: activityInfo().activityType }
-	});
-	return host.run(metaFor(), (scope) => unit === void 0 ? next() : scope.fork(unit, [[ActivityInputPort, invocation.input]]).flatMap((forked) => next({ context: { [UNIT_SCOPE]: forked } }))).tap(() => settle({ outcome: "ok" })).tapFailure((failure) => settle({
-		outcome: "error",
-		cause: failure.tag === "Err" ? failure.error : failure.cause
-	}));
-};
+	},
+	meta: metaFor(),
+	unit,
+	seed: [ActivityInputPort, invocation.input],
+	next
+});
 /**
 * `UnitMeta.id` must be unique per unit, and a workflow id is **not** one: an
 * activity is retried under the same execution. A task token identifies one
@@ -150,7 +111,17 @@ const activityUnits = (host, observers, unit) => (invocation, next) => {
 *
 * The workflow id becomes the `traceId` — minted outside this process and steady
 * across every retry, so all attempts join up in a log. An activity with no
-* workflow falls back to the activity id.
+* workflow falls back to the activity id; `workflowExecution` is optional
+* because Temporal's own `Info` declares it so, "not set if the activity was
+* not started by a Workflow", which a worker polling a task queue never sees.
+*
+* **A REUSED workflow id merges its runs into one trace**, and that is the
+* trade rather than an oversight: Temporal allows an id again once the previous
+* execution closed, so `order-42` run twice is one `traceId` over two runs.
+* `runId` would separate them and is the wrong correlation for this transport —
+* server-minted, opaque, and not what an operator greps for. A deployment that
+* needs per-run traces gives its workflows unique ids, which is what a Schedule
+* already does.
 */
 const metaFor = () => {
 	const info = activityInfo();
@@ -241,10 +212,7 @@ const temporal = (options) => {
 				})),
 				release: (connection) => connection.close().catch((cause) => heldByWorker(cause) ? void 0 : Promise.reject(cause))
 			}),
-			Provider.member(Observers)({
-				inject: {},
-				value: noObserver
-			}),
+			noObserverMember,
 			Provider(TemporalRuntime)({
 				inject: {
 					connection: TemporalConnection,
@@ -372,19 +340,7 @@ const TemporalModule = (name) => (options) => {
 * and two slices claiming one key are di's duplicate-provider defect at build.
 */
 const TemporalActivities = (contract) => {
-	const build = Provider(TemporalActivitiesPort);
-	const compose = (pieces) => build({
-		inject: Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(27), piece.port])),
-		sync: (services) => services
-	});
-	const whole = (options) => {
-		const record = options.unit ?? {};
-		return build({
-			inject: options.inject,
-			sync: (services) => Object.fromEntries(Object.entries(options.sync(services)).map(([key, entry]) => [key, withUnit(record, entry)]))
-		});
-	};
-	return ((first) => Array.isArray(first) ? compose(first) : whole(first));
+	return composeByPrefix(TemporalActivitiesPort, WORKFLOW_ACTIVITIES_PREFIX, withUnit);
 };
 //#endregion
 export { ActivityInput, TemporalActivities, TemporalConfig, TemporalConnection, TemporalModule, TemporalRuntime, TemporalUnreachable, TemporalWorkflowActivities, temporal };

package/dist/schedule.cjs

@@ -16,24 +16,29 @@ let _temporal_contract_client = require("@temporal-contract/client");
 * This recovers exactly that one error into an `update`. Every other error
 * stays on the channel, still typed.
 *
-* **`spec` is the only field reconciled**, and the rest of an existing
-* schedule is left as it stands. Two different reasons, and they are worth
-* telling apart:
+* **`spec`, the action's `workflowType` and `args`, and `policies` are
+* reconciled**; everything else about an existing schedule is left as it
+* stands.
 *
+* - **`args` and `workflowType` are written, and they are checked on the way
+*   through.** The typed handle's `update` validates the returned action's
+*   `args` against the named workflow's input schema before anything is
+*   persisted, and answers `WorkflowValidationError` — the same error `create`
+*   answers, already on this channel. So a deploy that changed what the
+*   workflow takes is either written or refused, never reported `"updated"`
+*   over a server still holding the old action. `workflowType` rides with them
+*   because it is what selects the schema those args are checked against.
 * - **`state` is deliberately preserved.** A schedule an operator paused stays
 *   paused across a deploy, because unpausing it is a decision a person made
 *   and a deploy is not the place to reverse it.
-* - **`args` and the rest of the action are preserved because this cannot
-*   reconcile them SAFELY.** `create` validates `args` against the workflow's
-*   input schema; the handle's `update` takes Temporal's own
-*   `ScheduleUpdateOptions` and validates nothing, so writing them here would
-*   push unvalidated input at the server through a door the typed client keeps
-*   shut. A deploy that changes what a schedule RUNS — its args, its workflow,
-*   its policies — should say so explicitly: delete the schedule and create it,
-*   or reach `getHandle(id).update(...)` directly and own the shape.
+* - **`memo`, `searchAttributes` and the action's own overrides are
+*   preserved**, because rebuilding the action wholesale means reproducing
+*   `create`'s own assembly here — the task queue off the contract, the search
+*   attribute translation, eight optional overrides — which is a copy that
+*   drifts. A deploy changing one of those deletes the schedule and creates it.
 *
-* So: after this call the schedule FIRES when the arguments say. What it fires
-* with is whatever it already fired with.
+* So: after this call the schedule FIRES when the arguments say, and RUNS what
+* they say.
 *
 * ```ts
 * await ensureSchedule(client.for(orderContract).schedule, "sweepStaleOrders", {
@@ -45,7 +50,13 @@ let _temporal_contract_client = require("@temporal-contract/client");
 */
 const ensureSchedule = (schedules, workflow, options) => schedules.create(workflow, options).map(() => "created").flatMapErrCases((matcher) => matcher.with(unthrown.P.tag(_temporal_contract_client.SCHEDULE_ALREADY_EXISTS_ERROR_TAG), () => schedules.getHandle(options.scheduleId).update((previous) => ({
 	...previous,
-	spec: options.spec
+	spec: options.spec,
+	action: {
+		...previous.action,
+		workflowType: workflow,
+		args: [options.args]
+	},
+	...options.policies === void 0 ? {} : { policies: options.policies }
 })).map(() => "updated")).with(unthrown.P.tag("@temporal-contract/WorkflowNotInContractError"), (error) => (0, unthrown.ErrAsync)(error)).with(unthrown.P.tag("@temporal-contract/WorkflowValidationError"), (error) => (0, unthrown.ErrAsync)(error)));
 //#endregion
 exports.ensureSchedule = ensureSchedule;

package/dist/schedule.d.cts

@@ -18,24 +18,29 @@ export type ScheduleOutcome = "created" | "updated";
  * This recovers exactly that one error into an `update`. Every other error
  * stays on the channel, still typed.
  *
- * **`spec` is the only field reconciled**, and the rest of an existing
- * schedule is left as it stands. Two different reasons, and they are worth
- * telling apart:
+ * **`spec`, the action's `workflowType` and `args`, and `policies` are
+ * reconciled**; everything else about an existing schedule is left as it
+ * stands.
  *
+ * - **`args` and `workflowType` are written, and they are checked on the way
+ *   through.** The typed handle's `update` validates the returned action's
+ *   `args` against the named workflow's input schema before anything is
+ *   persisted, and answers `WorkflowValidationError` — the same error `create`
+ *   answers, already on this channel. So a deploy that changed what the
+ *   workflow takes is either written or refused, never reported `"updated"`
+ *   over a server still holding the old action. `workflowType` rides with them
+ *   because it is what selects the schema those args are checked against.
  * - **`state` is deliberately preserved.** A schedule an operator paused stays
  *   paused across a deploy, because unpausing it is a decision a person made
  *   and a deploy is not the place to reverse it.
- * - **`args` and the rest of the action are preserved because this cannot
- *   reconcile them SAFELY.** `create` validates `args` against the workflow's
- *   input schema; the handle's `update` takes Temporal's own
- *   `ScheduleUpdateOptions` and validates nothing, so writing them here would
- *   push unvalidated input at the server through a door the typed client keeps
- *   shut. A deploy that changes what a schedule RUNS — its args, its workflow,
- *   its policies — should say so explicitly: delete the schedule and create it,
- *   or reach `getHandle(id).update(...)` directly and own the shape.
+ * - **`memo`, `searchAttributes` and the action's own overrides are
+ *   preserved**, because rebuilding the action wholesale means reproducing
+ *   `create`'s own assembly here — the task queue off the contract, the search
+ *   attribute translation, eight optional overrides — which is a copy that
+ *   drifts. A deploy changing one of those deletes the schedule and creates it.
  *
- * So: after this call the schedule FIRES when the arguments say. What it fires
- * with is whatever it already fired with.
+ * So: after this call the schedule FIRES when the arguments say, and RUNS what
+ * they say.
  *
  * ```ts
  * await ensureSchedule(client.for(orderContract).schedule, "sweepStaleOrders", {

package/dist/schedule.d.mts

@@ -18,24 +18,29 @@ export type ScheduleOutcome = "created" | "updated";
  * This recovers exactly that one error into an `update`. Every other error
  * stays on the channel, still typed.
  *
- * **`spec` is the only field reconciled**, and the rest of an existing
- * schedule is left as it stands. Two different reasons, and they are worth
- * telling apart:
+ * **`spec`, the action's `workflowType` and `args`, and `policies` are
+ * reconciled**; everything else about an existing schedule is left as it
+ * stands.
  *
+ * - **`args` and `workflowType` are written, and they are checked on the way
+ *   through.** The typed handle's `update` validates the returned action's
+ *   `args` against the named workflow's input schema before anything is
+ *   persisted, and answers `WorkflowValidationError` — the same error `create`
+ *   answers, already on this channel. So a deploy that changed what the
+ *   workflow takes is either written or refused, never reported `"updated"`
+ *   over a server still holding the old action. `workflowType` rides with them
+ *   because it is what selects the schema those args are checked against.
  * - **`state` is deliberately preserved.** A schedule an operator paused stays
  *   paused across a deploy, because unpausing it is a decision a person made
  *   and a deploy is not the place to reverse it.
- * - **`args` and the rest of the action are preserved because this cannot
- *   reconcile them SAFELY.** `create` validates `args` against the workflow's
- *   input schema; the handle's `update` takes Temporal's own
- *   `ScheduleUpdateOptions` and validates nothing, so writing them here would
- *   push unvalidated input at the server through a door the typed client keeps
- *   shut. A deploy that changes what a schedule RUNS — its args, its workflow,
- *   its policies — should say so explicitly: delete the schedule and create it,
- *   or reach `getHandle(id).update(...)` directly and own the shape.
+ * - **`memo`, `searchAttributes` and the action's own overrides are
+ *   preserved**, because rebuilding the action wholesale means reproducing
+ *   `create`'s own assembly here — the task queue off the contract, the search
+ *   attribute translation, eight optional overrides — which is a copy that
+ *   drifts. A deploy changing one of those deletes the schedule and creates it.
  *
- * So: after this call the schedule FIRES when the arguments say. What it fires
- * with is whatever it already fired with.
+ * So: after this call the schedule FIRES when the arguments say, and RUNS what
+ * they say.
  *
  * ```ts
  * await ensureSchedule(client.for(orderContract).schedule, "sweepStaleOrders", {

package/dist/schedule.mjs

@@ -15,24 +15,29 @@ import { SCHEDULE_ALREADY_EXISTS_ERROR_TAG } from "@temporal-contract/client";
 * This recovers exactly that one error into an `update`. Every other error
 * stays on the channel, still typed.
 *
-* **`spec` is the only field reconciled**, and the rest of an existing
-* schedule is left as it stands. Two different reasons, and they are worth
-* telling apart:
+* **`spec`, the action's `workflowType` and `args`, and `policies` are
+* reconciled**; everything else about an existing schedule is left as it
+* stands.
 *
+* - **`args` and `workflowType` are written, and they are checked on the way
+*   through.** The typed handle's `update` validates the returned action's
+*   `args` against the named workflow's input schema before anything is
+*   persisted, and answers `WorkflowValidationError` — the same error `create`
+*   answers, already on this channel. So a deploy that changed what the
+*   workflow takes is either written or refused, never reported `"updated"`
+*   over a server still holding the old action. `workflowType` rides with them
+*   because it is what selects the schema those args are checked against.
 * - **`state` is deliberately preserved.** A schedule an operator paused stays
 *   paused across a deploy, because unpausing it is a decision a person made
 *   and a deploy is not the place to reverse it.
-* - **`args` and the rest of the action are preserved because this cannot
-*   reconcile them SAFELY.** `create` validates `args` against the workflow's
-*   input schema; the handle's `update` takes Temporal's own
-*   `ScheduleUpdateOptions` and validates nothing, so writing them here would
-*   push unvalidated input at the server through a door the typed client keeps
-*   shut. A deploy that changes what a schedule RUNS — its args, its workflow,
-*   its policies — should say so explicitly: delete the schedule and create it,
-*   or reach `getHandle(id).update(...)` directly and own the shape.
+* - **`memo`, `searchAttributes` and the action's own overrides are
+*   preserved**, because rebuilding the action wholesale means reproducing
+*   `create`'s own assembly here — the task queue off the contract, the search
+*   attribute translation, eight optional overrides — which is a copy that
+*   drifts. A deploy changing one of those deletes the schedule and creates it.
 *
-* So: after this call the schedule FIRES when the arguments say. What it fires
-* with is whatever it already fired with.
+* So: after this call the schedule FIRES when the arguments say, and RUNS what
+* they say.
 *
 * ```ts
 * await ensureSchedule(client.for(orderContract).schedule, "sweepStaleOrders", {
@@ -44,7 +49,13 @@ import { SCHEDULE_ALREADY_EXISTS_ERROR_TAG } from "@temporal-contract/client";
 */
 const ensureSchedule = (schedules, workflow, options) => schedules.create(workflow, options).map(() => "created").flatMapErrCases((matcher) => matcher.with(P.tag(SCHEDULE_ALREADY_EXISTS_ERROR_TAG), () => schedules.getHandle(options.scheduleId).update((previous) => ({
 	...previous,
-	spec: options.spec
+	spec: options.spec,
+	action: {
+		...previous.action,
+		workflowType: workflow,
+		args: [options.args]
+	},
+	...options.policies === void 0 ? {} : { policies: options.policies }
 })).map(() => "updated")).with(P.tag("@temporal-contract/WorkflowNotInContractError"), (error) => ErrAsync(error)).with(P.tag("@temporal-contract/WorkflowValidationError"), (error) => ErrAsync(error)));
 //#endregion
 export { ensureSchedule };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/temporal-worker",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "The Temporal worker runtime for @btravstack/core: one unit per activity attempt, and a drain that honours the kernel's deadline",
   "keywords": [
     "graceful-shutdown",
@@ -54,33 +54,33 @@
     }
   },
   "devDependencies": {
-    "@btravstack/config": "0.15.0",
-    "@btravstack/core": "0.15.0",
-    "@btravstack/di": "0.15.0",
+    "@btravstack/config": "0.17.0",
+    "@btravstack/core": "0.17.0",
+    "@btravstack/di": "0.17.0",
     "@btravstack/internal-test-infra": "0.0.0",
-    "@btravstack/testing": "0.15.0",
+    "@btravstack/testing": "0.17.0",
     "@btravstack/tsconfig": "0.4.0",
-    "@temporal-contract/client": "8.0.0-beta.9",
-    "@temporal-contract/contract": "8.0.0-beta.9",
-    "@temporal-contract/worker": "8.0.0-beta.9",
-    "@temporalio/activity": "1.23.0",
-    "@temporalio/client": "1.23.0",
-    "@temporalio/common": "1.23.0",
-    "@temporalio/worker": "1.23.0",
-    "@temporalio/workflow": "1.23.0",
-    "@types/node": "26.4.1",
-    "@unthrown/vitest": "5.8.0",
-    "@vitest/coverage-v8": "4.1.11",
+    "@temporal-contract/client": "8.0.0-beta.11",
+    "@temporal-contract/contract": "8.0.0-beta.11",
+    "@temporal-contract/worker": "8.0.0-beta.11",
+    "@temporalio/activity": "1.24.0",
+    "@temporalio/client": "1.24.0",
+    "@temporalio/common": "1.24.0",
+    "@temporalio/worker": "1.24.0",
+    "@temporalio/workflow": "1.24.0",
+    "@types/node": "26.6.4",
+    "@unthrown/vitest": "5.12.0",
+    "@vitest/coverage-v8": "5.0.3",
     "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "unthrown": "5.8.0",
-    "vitest": "4.1.11",
-    "zod": "4.5.4"
+    "unthrown": "5.12.0",
+    "vitest": "5.0.3",
+    "zod": "4.6.5"
   },
   "peerDependencies": {
-    "@btravstack/config": "^0.15.0",
-    "@btravstack/core": "^0.15.0",
-    "@btravstack/di": "^0.15.0",
+    "@btravstack/config": "^0.17.0",
+    "@btravstack/core": "^0.17.0",
+    "@btravstack/di": "^0.17.0",
     "@temporal-contract/client": "^8.0.0-beta.9",
     "@temporal-contract/contract": "^8.0.0-beta.9",
     "@temporal-contract/worker": "^8.0.0-beta.9",