@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/logix-core/StateTrait.js

@@ -5,32 +5,35 @@ import {
   build,
   computed,
   exportStaticIr,
+  externalStore,
   from,
   install,
   link,
   list,
   node,
   source
-} from "../chunks/chunk-CDLXJHXY.js";
-import "../chunks/chunk-MPUSOFJ3.js";
-import "../chunks/chunk-HFV5GJPK.js";
-import "../chunks/chunk-CEGSWZ5S.js";
+} from "../chunks/chunk-NE447XAF.js";
+import "../chunks/chunk-FQRUTYAD.js";
+import "../chunks/chunk-C2MYMMO4.js";
+import "../chunks/chunk-EZTMVCJF.js";
 import "../chunks/chunk-KE2H62D6.js";
-import "../chunks/chunk-WFV5PPWJ.js";
-import "../chunks/chunk-ON2LY6HJ.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+import "../chunks/chunk-4MY35XR3.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-NMGFJZ4I.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-DT7YIIWE.js";
 export {
   $root,
   build,
   computed,
   exportStaticIr,
+  externalStore,
   from,
   install,
   link,

package/public/sandbox/logix-core/TraitLifecycle.js

@@ -3,17 +3,17 @@
 import {
   ReplayLog,
   unsetAtPathMutating
-} from "../chunks/chunk-HFV5GJPK.js";
-import {
-  inSyncTransactionFiber
-} from "../chunks/chunk-WFV5PPWJ.js";
+} from "../chunks/chunk-C2MYMMO4.js";
 import {
   getBoundInternals,
   getModuleTraitsProgram
-} from "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+} from "../chunks/chunk-7GPAF2UK.js";
+import {
+  inSyncTransactionFiber
+} from "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
 
 // ../logix-core/src/internal/trait-lifecycle/index.ts
 import { Effect, FiberRef, Option } from "../effect.js";

package/public/sandbox/logix-core/Workflow.js

@@ -0,0 +1,332 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  installOne
+} from "../chunks/chunk-DM7C5NP5.js";
+import {
+  compileWorkflowStaticIrV1,
+  makeWorkflowError,
+  normalizeWorkflowDefV1,
+  validateWorkflowDefV1
+} from "../chunks/chunk-UZZBHWIO.js";
+import "../chunks/chunk-BJOWSSEL.js";
+import "../chunks/chunk-UBMUY7WO.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-DT7YIIWE.js";
+
+// ../logix-core/src/Workflow.ts
+import { Context } from "../effect.js";
+
+// ../logix-core/src/internal/serviceId.ts
+var asNonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var fromTag = (tag) => {
+  const anyTag = tag;
+  return asNonEmptyString(anyTag.key) ?? asNonEmptyString(anyTag.id) ?? asNonEmptyString(anyTag._id);
+};
+
+// ../logix-core/src/Workflow.ts
+var KernelSourceRefreshPortTagImpl = class extends Context.Tag("logix/kernel/sourceRefresh")() {
+};
+var KernelPorts = {
+  sourceRefresh: KernelSourceRefreshPortTagImpl
+};
+var forModule = (_module) => {
+  return {
+    onAction: (actionTag) => onAction(actionTag),
+    onStart,
+    onInit,
+    payload,
+    payloadPath,
+    constValue,
+    object,
+    merge,
+    dispatch: (args) => dispatch(args),
+    delay,
+    callById: (args) => callById(args),
+    call: (args) => call(args),
+    fragment: (fragmentId, steps) => fragment(fragmentId, steps),
+    withPolicy: (patch, part) => withPolicy(patch, part),
+    compose: (...parts) => compose(...parts),
+    make: (input) => make(input),
+    fromJSON: (def) => fromJSON(def)
+  };
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isReadonlyArray = (value) => Array.isArray(value);
+var asNonEmptyString2 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var mergePolicy = (base, patch) => {
+  if (!base && !patch) return void 0;
+  return {
+    ...base ?? {},
+    ...patch ?? {}
+  };
+};
+var applyCallDefaults = (steps, patch) => {
+  const timeoutMsDefault = patch.timeoutMs;
+  const retryDefault = patch.retry;
+  const visit = (step) => {
+    if (step.kind !== "call") return step;
+    let changed = false;
+    const timeoutMs = step.timeoutMs ?? timeoutMsDefault;
+    if (timeoutMs !== step.timeoutMs) changed = true;
+    const retry = step.retry ?? retryDefault;
+    if (retry !== step.retry) changed = true;
+    const onSuccess = step.onSuccess.map(visit);
+    const onFailure = step.onFailure.map(visit);
+    if (onSuccess !== step.onSuccess) changed = true;
+    if (onFailure !== step.onFailure) changed = true;
+    if (!changed) return step;
+    return {
+      ...step,
+      ...timeoutMs !== void 0 ? { timeoutMs } : null,
+      ...retry !== void 0 ? { retry } : null,
+      onSuccess,
+      onFailure
+    };
+  };
+  return steps.map(visit);
+};
+var resolveStepsInput = (input) => {
+  if (Array.isArray(input)) {
+    return { steps: input };
+  }
+  if (isRecord(input) && Array.isArray(input.steps)) {
+    return input;
+  }
+  throw makeWorkflowError({
+    code: "WORKFLOW_INVALID_DEF",
+    message: 'Workflow.make: "steps" must be an array or a { steps, sources?, policy? } object.',
+    detail: { steps: input }
+  });
+};
+var recordSourcesForFragment = (sources, fragmentId, step) => {
+  sources[step.key] = { fragmentId };
+  if (step.kind !== "call") return;
+  for (const inner of step.onSuccess) recordSourcesForFragment(sources, fragmentId, inner);
+  for (const inner of step.onFailure) recordSourcesForFragment(sources, fragmentId, inner);
+};
+var onAction = (actionTag) => ({
+  kind: "action",
+  actionTag
+});
+var onStart = () => ({
+  kind: "lifecycle",
+  phase: "onStart"
+});
+var onInit = () => ({
+  kind: "lifecycle",
+  phase: "onInit"
+});
+var payload = () => ({ kind: "payload" });
+var payloadPath = (pointer) => ({ kind: "payload.path", pointer });
+var constValue = (value) => ({ kind: "const", value });
+var object = (fields) => ({ kind: "object", fields });
+var merge = (items) => ({ kind: "merge", items });
+var dispatch = (args) => ({
+  kind: "dispatch",
+  key: args.key,
+  actionTag: args.actionTag,
+  ...args.payload ? { payload: args.payload } : null
+});
+var delay = (args) => ({
+  kind: "delay",
+  key: args.key,
+  ms: args.ms
+});
+var callById = (args) => ({
+  kind: "call",
+  key: args.key,
+  serviceId: args.serviceId,
+  ...args.input ? { input: args.input } : null,
+  ...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : null,
+  ...args.retry ? { retry: args.retry } : null,
+  onSuccess: args.onSuccess ?? [],
+  onFailure: args.onFailure ?? []
+});
+var call = (args) => {
+  const serviceId = fromTag(args.service);
+  if (!serviceId) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_SERVICE_ID",
+      message: "call(service): serviceId derived from tag must be a non-empty string (see 078 ServiceId contract).",
+      detail: { tag: String(args.service) }
+    });
+  }
+  return callById({
+    ...args,
+    serviceId
+  });
+};
+var fragment = (fragmentId, steps) => ({
+  fragmentId,
+  steps
+});
+var withPolicy = (patch, part) => {
+  let normalized;
+  if (isReadonlyArray(part)) {
+    normalized = { steps: part };
+  } else {
+    const partUnknown = part;
+    if (!isRecord(partUnknown) || !isReadonlyArray(partUnknown.steps)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "withPolicy: invalid workflow part (expected steps[] / fragment / composeResult).",
+        detail: { part }
+      });
+    }
+    normalized = {
+      steps: part.steps,
+      ...part.sources ? { sources: part.sources } : null,
+      ...part.policy ? { policy: part.policy } : null
+    };
+  }
+  const steps = applyCallDefaults(normalized.steps, patch);
+  const patchPolicy = (() => {
+    const concurrency = patch.concurrency;
+    const priority = patch.priority;
+    return concurrency !== void 0 || priority !== void 0 ? { concurrency, priority } : void 0;
+  })();
+  const nextPolicy = mergePolicy(patchPolicy, normalized.policy);
+  return {
+    steps,
+    ...normalized.sources ? { sources: normalized.sources } : null,
+    ...nextPolicy ? { policy: nextPolicy } : null
+  };
+};
+var compose = (...parts) => {
+  const steps = [];
+  const sources = {};
+  let policy = void 0;
+  const ownersByKey = /* @__PURE__ */ new Map();
+  const recordOwner = (stepKey, fragmentId) => {
+    const list = ownersByKey.get(stepKey) ?? [];
+    list.push({ stepKey, ...fragmentId ? { fragmentId } : null });
+    ownersByKey.set(stepKey, list);
+  };
+  const recordOwners = (step, resolveFragmentId) => {
+    recordOwner(step.key, resolveFragmentId(step.key));
+    if (step.kind !== "call") return;
+    for (const inner of step.onSuccess) recordOwners(inner, resolveFragmentId);
+    for (const inner of step.onFailure) recordOwners(inner, resolveFragmentId);
+  };
+  for (const part of parts) {
+    if (isReadonlyArray(part)) {
+      steps.push(...part);
+      for (const step of part) recordOwners(step, () => void 0);
+      continue;
+    }
+    const partSteps = part.steps;
+    steps.push(...partSteps);
+    const partSources = part.sources;
+    if (partSources && typeof partSources === "object") {
+      for (const k of Object.keys(partSources).sort()) {
+        sources[k] = { ...partSources[k] };
+      }
+    }
+    const fragmentId = "fragmentId" in part ? part.fragmentId : void 0;
+    if (typeof fragmentId === "string" && fragmentId.length > 0) {
+      for (const step of partSteps) {
+        recordSourcesForFragment(sources, fragmentId, step);
+      }
+    }
+    const resolveFragmentIdForPart = (stepKey) => {
+      if (typeof fragmentId === "string" && fragmentId.length > 0) return fragmentId;
+      const fromSources = partSources?.[stepKey]?.fragmentId;
+      return typeof fromSources === "string" && fromSources.length > 0 ? fromSources : void 0;
+    };
+    for (const step of partSteps) recordOwners(step, resolveFragmentIdForPart);
+    policy = mergePolicy(policy, part.policy);
+  }
+  const finalSources = Object.keys(sources).length > 0 ? sources : void 0;
+  const duplicateKeys = Array.from(ownersByKey.entries()).filter(([, owners]) => owners.length > 1).map(([k]) => k).sort();
+  if (duplicateKeys.length > 0) {
+    const k = duplicateKeys[0];
+    throw makeWorkflowError({
+      code: "WORKFLOW_DUPLICATE_STEP_KEY",
+      message: `Duplicate stepKey "${k}" detected during composition.`,
+      source: { stepKey: k },
+      detail: { duplicateKey: k, owners: ownersByKey.get(k) ?? [] }
+    });
+  }
+  return {
+    steps,
+    ...finalSources ? { sources: finalSources } : null,
+    ...policy ? { policy } : null
+  };
+};
+var make = (input) => {
+  const localId = asNonEmptyString2(input.localId);
+  if (!localId) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "Workflow.make: localId must be a non-empty string.",
+      detail: { localId: input.localId }
+    });
+  }
+  const stepsInput = resolveStepsInput(input.steps);
+  const merged = mergePolicy(input.policy, stepsInput.policy);
+  const def = normalizeWorkflowDefV1({
+    astVersion: 1,
+    localId,
+    trigger: input.trigger,
+    ...merged ? { policy: merged } : null,
+    steps: stepsInput.steps,
+    ...stepsInput.sources ? { sources: stepsInput.sources } : null,
+    ...input.meta ? { meta: input.meta } : null
+  });
+  const staticIrCache = /* @__PURE__ */ new Map();
+  return {
+    _tag: "Workflow",
+    def,
+    toJSON: () => def,
+    validate: () => validateWorkflowDefV1(def),
+    exportStaticIr: (moduleId) => {
+      const cached = staticIrCache.get(moduleId);
+      if (cached) return cached;
+      const ir = compileWorkflowStaticIrV1({ moduleId, def });
+      staticIrCache.set(moduleId, ir);
+      return ir;
+    },
+    install: (moduleTag) => installOne({
+      moduleTag,
+      program: { _tag: "Workflow", def }
+    })
+  };
+};
+var fromJSON = (def) => make({
+  localId: def.localId,
+  trigger: def.trigger,
+  ...def.policy ? { policy: def.policy } : null,
+  steps: {
+    steps: def.steps,
+    ...def.sources ? { sources: def.sources } : null
+  },
+  ...def.meta ? { meta: def.meta } : null
+});
+export {
+  KernelPorts,
+  call,
+  callById,
+  compose,
+  constValue,
+  delay,
+  dispatch,
+  forModule,
+  fragment,
+  fromJSON,
+  make,
+  merge,
+  object,
+  onAction,
+  onInit,
+  onStart,
+  payload,
+  payloadPath,
+  withPolicy
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Workflow.ts", "../../../../logix-core/src/internal/serviceId.ts"],
  "sourcesContent": ["import { Context } from 'effect'\nimport type { JsonValue } from './internal/observability/jsonValue.js'\nimport { fromTag as serviceIdFromTag } from './internal/serviceId.js'\nimport { makeWorkflowError } from './internal/workflow/errors.js'\nimport type { AnyModuleShape, ModuleLogic, ModuleTag } from './internal/module.js'\nimport type {\n  InputExprV1,\n  WorkflowComposeResultV1,\n  WorkflowDefV1,\n  WorkflowFragmentV1,\n  WorkflowPartV1,\n  WorkflowPolicyV1,\n  WorkflowStaticIrV1,\n  WorkflowStepV1,\n  WorkflowTriggerV1,\n} from './internal/workflow/model.js'\nimport { compileWorkflowStaticIrV1, normalizeWorkflowDefV1, validateWorkflowDefV1 } from './internal/workflow/compiler.js'\nimport * as WorkflowRuntime from './internal/runtime/core/WorkflowRuntime.js'\n\nexport type ActionTagsOfModule<M> = M extends { readonly actions: infer A } ? Extract<keyof A, string> : string\n\nexport type WorkflowTrigger<ActionTag extends string = string> =\n  | { readonly kind: 'action'; readonly actionTag: ActionTag }\n  | { readonly kind: 'lifecycle'; readonly phase: 'onStart' | 'onInit' }\n\nexport type WorkflowPolicy = WorkflowPolicyV1\n\nexport type WorkflowStep<ActionTag extends string = string> =\n  | { readonly kind: 'dispatch'; readonly key: string; readonly actionTag: ActionTag; readonly payload?: InputExprV1 }\n  | { readonly kind: 'delay'; readonly key: string; readonly ms: number }\n  | {\n      readonly kind: 'call'\n      readonly key: string\n      readonly serviceId: string\n      readonly input?: InputExprV1\n      readonly timeoutMs?: number\n      readonly retry?: { readonly times: number }\n      readonly onSuccess: ReadonlyArray<WorkflowStep<ActionTag>>\n      readonly onFailure: ReadonlyArray<WorkflowStep<ActionTag>>\n    }\n\nexport type WorkflowDef<ActionTag extends string = string> = {\n  readonly astVersion: 1\n  readonly localId: string\n  readonly trigger: WorkflowTrigger<ActionTag>\n  readonly policy?: WorkflowPolicyV1\n  readonly steps: ReadonlyArray<WorkflowStep<ActionTag>>\n  readonly sources?: WorkflowDefV1['sources']\n  readonly meta?: { readonly generator?: JsonValue }\n}\n\nexport type WorkflowStaticIr = WorkflowStaticIrV1\nexport type InputExpr = InputExprV1\n\nexport type WorkflowFragment<ActionTag extends string = string> = {\n  readonly fragmentId: string\n  readonly steps: ReadonlyArray<WorkflowStep<ActionTag>>\n  readonly sources?: WorkflowDefV1['sources']\n  readonly policy?: WorkflowPolicyV1\n}\n\nexport type WorkflowComposeResult<ActionTag extends string = string> = {\n  readonly steps: ReadonlyArray<WorkflowStep<ActionTag>>\n  readonly sources?: WorkflowDefV1['sources']\n  readonly policy?: WorkflowPolicyV1\n}\n\nexport type WorkflowPart<ActionTag extends string = string> =\n  | ReadonlyArray<WorkflowStep<ActionTag>>\n  | WorkflowFragment<ActionTag>\n  | WorkflowComposeResult<ActionTag>\n\nclass KernelSourceRefreshPortTagImpl extends Context.Tag('logix/kernel/sourceRefresh')<\n  KernelSourceRefreshPortTagImpl,\n  unknown\n>() {}\n\nexport const KernelPorts = {\n  sourceRefresh: KernelSourceRefreshPortTagImpl,\n} as const\n\nexport const forModule = <M extends { readonly actions: Record<string, unknown> }>(_module: M) => {\n  type ActionTag = ActionTagsOfModule<M>\n\n  return {\n    onAction: (actionTag: ActionTag) => onAction(actionTag),\n    onStart,\n    onInit,\n    payload,\n    payloadPath,\n    constValue,\n    object,\n    merge,\n    dispatch: (args: { readonly key: string; readonly actionTag: ActionTag; readonly payload?: InputExpr }) => dispatch(args),\n    delay,\n    callById: (args: {\n      readonly key: string\n      readonly serviceId: string\n      readonly input?: InputExpr\n      readonly timeoutMs?: number\n      readonly retry?: { readonly times: number }\n      readonly onSuccess?: ReadonlyArray<WorkflowStep<ActionTag>>\n      readonly onFailure?: ReadonlyArray<WorkflowStep<ActionTag>>\n    }) => callById<ActionTag>(args),\n    call: <Id, Svc>(args: {\n      readonly key: string\n      readonly service: Context.Tag<Id, Svc>\n      readonly input?: InputExpr\n      readonly timeoutMs?: number\n      readonly retry?: { readonly times: number }\n      readonly onSuccess?: ReadonlyArray<WorkflowStep<ActionTag>>\n      readonly onFailure?: ReadonlyArray<WorkflowStep<ActionTag>>\n    }) => call(args),\n    fragment: (fragmentId: string, steps: ReadonlyArray<WorkflowStep<ActionTag>>) => fragment<ActionTag>(fragmentId, steps),\n    withPolicy: (patch: WithPolicyPatch, part: WorkflowPart<ActionTag>) => withPolicy<ActionTag>(patch, part),\n    compose: (...parts: ReadonlyArray<WorkflowPart<ActionTag>>) => compose<ActionTag>(...parts),\n    make: (input: {\n      readonly astVersion?: 1\n      readonly localId: string\n      readonly trigger: WorkflowTrigger<ActionTag>\n      readonly policy?: WorkflowPolicy\n      readonly steps: WorkflowStepsInput<ActionTag>\n      readonly meta?: { readonly generator?: JsonValue }\n    }) => make<M>(input),\n    fromJSON: (def: WorkflowDef<ActionTag>) => fromJSON<ActionTag>(def),\n  } as const\n}\n\nexport type WithPolicyPatch = {\n  readonly concurrency?: WorkflowPolicyV1['concurrency']\n  readonly priority?: WorkflowPolicyV1['priority']\n  /** Default for call.timeoutMs (only fills when step.timeoutMs is missing). */\n  readonly timeoutMs?: number\n  /** Default for call.retry.times (only fills when step.retry is missing). */\n  readonly retry?: { readonly times: number }\n}\n\nexport type WorkflowStepsInput<ActionTag extends string = string> =\n  | ReadonlyArray<WorkflowStep<ActionTag>>\n  | (WorkflowComposeResult<ActionTag> & {\n      readonly steps: ReadonlyArray<WorkflowStep<ActionTag>>\n    })\n\nexport interface Workflow {\n  readonly _tag: 'Workflow'\n  readonly def: WorkflowDefV1\n  readonly toJSON: () => WorkflowDefV1\n  readonly validate: () => void\n  readonly exportStaticIr: (moduleId: string) => WorkflowStaticIrV1\n  readonly install: (moduleTag: ModuleTag<string, AnyModuleShape>) => ModuleLogic<AnyModuleShape, unknown, never>\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nconst isReadonlyArray = (value: unknown): value is ReadonlyArray<unknown> => Array.isArray(value)\n\nconst asNonEmptyString = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined\n\nconst mergePolicy = (base: WorkflowPolicyV1 | undefined, patch: WorkflowPolicyV1 | undefined): WorkflowPolicyV1 | undefined => {\n  if (!base && !patch) return undefined\n  return {\n    ...(base ?? {}),\n    ...(patch ?? {}),\n  }\n}\n\nconst applyCallDefaults = (steps: ReadonlyArray<WorkflowStepV1>, patch: WithPolicyPatch): ReadonlyArray<WorkflowStepV1> => {\n  const timeoutMsDefault = patch.timeoutMs\n  const retryDefault = patch.retry\n\n  const visit = (step: WorkflowStepV1): WorkflowStepV1 => {\n    if (step.kind !== 'call') return step\n\n    let changed = false\n    const timeoutMs = step.timeoutMs ?? timeoutMsDefault\n    if (timeoutMs !== step.timeoutMs) changed = true\n\n    const retry = step.retry ?? retryDefault\n    if (retry !== step.retry) changed = true\n\n    const onSuccess = step.onSuccess.map(visit)\n    const onFailure = step.onFailure.map(visit)\n    if (onSuccess !== step.onSuccess) changed = true\n    if (onFailure !== step.onFailure) changed = true\n\n    if (!changed) return step\n\n    return {\n      ...step,\n      ...(timeoutMs !== undefined ? { timeoutMs } : null),\n      ...(retry !== undefined ? { retry } : null),\n      onSuccess,\n      onFailure,\n    }\n  }\n\n  return steps.map(visit)\n}\n\nconst resolveStepsInput = (input: unknown): WorkflowComposeResultV1 => {\n  if (Array.isArray(input)) {\n    return { steps: input as ReadonlyArray<WorkflowStepV1> }\n  }\n  if (isRecord(input) && Array.isArray(input.steps)) {\n    return input as WorkflowComposeResultV1\n  }\n  throw makeWorkflowError({\n    code: 'WORKFLOW_INVALID_DEF',\n    message: 'Workflow.make: \"steps\" must be an array or a { steps, sources?, policy? } object.',\n    detail: { steps: input },\n  })\n}\n\nconst recordSourcesForFragment = (\n  sources: Record<string, { readonly fragmentId?: string }>,\n  fragmentId: string,\n  step: WorkflowStepV1,\n): void => {\n  sources[step.key] = { fragmentId }\n  if (step.kind !== 'call') return\n  for (const inner of step.onSuccess) recordSourcesForFragment(sources, fragmentId, inner)\n  for (const inner of step.onFailure) recordSourcesForFragment(sources, fragmentId, inner)\n}\n\nexport const onAction = <ActionTag extends string>(actionTag: ActionTag): Extract<WorkflowTrigger<ActionTag>, { kind: 'action' }> => ({\n  kind: 'action',\n  actionTag,\n})\n\nexport const onStart = (): { readonly kind: 'lifecycle'; readonly phase: 'onStart' } => ({\n  kind: 'lifecycle',\n  phase: 'onStart',\n})\n\nexport const onInit = (): { readonly kind: 'lifecycle'; readonly phase: 'onInit' } => ({\n  kind: 'lifecycle',\n  phase: 'onInit',\n})\n\nexport const payload = (): InputExprV1 => ({ kind: 'payload' })\n\nexport const payloadPath = (pointer: string): InputExprV1 => ({ kind: 'payload.path', pointer })\n\nexport const constValue = (value: JsonValue): InputExprV1 => ({ kind: 'const', value })\n\nexport const object = (fields: Record<string, InputExprV1>): InputExprV1 => ({ kind: 'object', fields })\n\nexport const merge = (items: ReadonlyArray<InputExprV1>): InputExprV1 => ({ kind: 'merge', items })\n\nexport const dispatch = <ActionTag extends string>(args: {\n  readonly key: string\n  readonly actionTag: ActionTag\n  readonly payload?: InputExprV1\n}): Extract<WorkflowStep<ActionTag>, { kind: 'dispatch' }> => ({\n  kind: 'dispatch',\n  key: args.key,\n  actionTag: args.actionTag,\n  ...(args.payload ? { payload: args.payload } : null),\n})\n\nexport const delay = (args: { readonly key: string; readonly ms: number }): Extract<WorkflowStep, { kind: 'delay' }> => ({\n  kind: 'delay',\n  key: args.key,\n  ms: args.ms,\n})\n\nexport const callById = <ActionTag extends string = never>(args: {\n  readonly key: string\n  readonly serviceId: string\n  readonly input?: InputExprV1\n  readonly timeoutMs?: number\n  readonly retry?: { readonly times: number }\n  readonly onSuccess?: ReadonlyArray<WorkflowStep<ActionTag>>\n  readonly onFailure?: ReadonlyArray<WorkflowStep<ActionTag>>\n}): Extract<WorkflowStep<ActionTag>, { kind: 'call' }> => ({\n  kind: 'call',\n  key: args.key,\n  serviceId: args.serviceId,\n  ...(args.input ? { input: args.input } : null),\n  ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : null),\n  ...(args.retry ? { retry: args.retry } : null),\n  onSuccess: args.onSuccess ?? [],\n  onFailure: args.onFailure ?? [],\n})\n\nexport const call = <Id, Svc, ActionTag extends string = never>(args: {\n  readonly key: string\n  readonly service: Context.Tag<Id, Svc>\n  readonly input?: InputExprV1\n  readonly timeoutMs?: number\n  readonly retry?: { readonly times: number }\n  readonly onSuccess?: ReadonlyArray<WorkflowStep<ActionTag>>\n  readonly onFailure?: ReadonlyArray<WorkflowStep<ActionTag>>\n}): Extract<WorkflowStep<ActionTag>, { kind: 'call' }> => {\n  const serviceId = serviceIdFromTag(args.service)\n  if (!serviceId) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_SERVICE_ID',\n      message: 'call(service): serviceId derived from tag must be a non-empty string (see 078 ServiceId contract).',\n      detail: { tag: String(args.service) },\n    })\n  }\n\n  return callById<ActionTag>({\n    ...args,\n    serviceId,\n  })\n}\n\nexport const fragment = <ActionTag extends string = never>(\n  fragmentId: string,\n  steps: ReadonlyArray<WorkflowStep<ActionTag>>,\n): WorkflowFragment<ActionTag> => ({\n  fragmentId,\n  steps,\n})\n\nexport const withPolicy = <ActionTag extends string = never>(\n  patch: WithPolicyPatch,\n  part: WorkflowPart<ActionTag>,\n): WorkflowComposeResult<ActionTag> => {\n  let normalized: WorkflowComposeResult<ActionTag>\n  if (isReadonlyArray(part)) {\n    normalized = { steps: part }\n  } else {\n    const partUnknown: unknown = part\n    if (!isRecord(partUnknown) || !isReadonlyArray(partUnknown.steps)) {\n      throw makeWorkflowError({\n        code: 'WORKFLOW_INVALID_DEF',\n        message: 'withPolicy: invalid workflow part (expected steps[] / fragment / composeResult).',\n        detail: { part },\n      })\n    }\n    normalized = {\n      steps: part.steps,\n      ...(part.sources ? { sources: part.sources } : null),\n      ...(part.policy ? { policy: part.policy } : null),\n    }\n  }\n\n  const steps = applyCallDefaults(normalized.steps as ReadonlyArray<WorkflowStepV1>, patch) as ReadonlyArray<WorkflowStep<ActionTag>>\n  const patchPolicy: WorkflowPolicyV1 | undefined = (() => {\n    const concurrency = patch.concurrency\n    const priority = patch.priority\n    return concurrency !== undefined || priority !== undefined ? { concurrency, priority } : undefined\n  })()\n\n  // Outer withPolicy is weaker than inner (nested) policies: only fill missing program policy fields.\n  const nextPolicy = mergePolicy(patchPolicy, normalized.policy)\n\n  return {\n    steps,\n    ...(normalized.sources ? { sources: normalized.sources } : null),\n    ...(nextPolicy ? { policy: nextPolicy } : null),\n  }\n}\n\nexport const compose = <ActionTag extends string = never>(\n  ...parts: ReadonlyArray<WorkflowPart<ActionTag>>\n): WorkflowComposeResult<ActionTag> => {\n  const steps: Array<WorkflowStep<ActionTag>> = []\n  const sources: Record<string, { readonly fragmentId?: string }> = {}\n  let policy: WorkflowPolicyV1 | undefined = undefined\n\n  const ownersByKey = new Map<string, Array<{ readonly stepKey: string; readonly fragmentId?: string }>>()\n\n  const recordOwner = (stepKey: string, fragmentId: string | undefined) => {\n    const list = ownersByKey.get(stepKey) ?? []\n    list.push({ stepKey, ...(fragmentId ? { fragmentId } : null) })\n    ownersByKey.set(stepKey, list)\n  }\n\n  const recordOwners = (\n    step: WorkflowStep<ActionTag>,\n    resolveFragmentId: (stepKey: string) => string | undefined,\n  ): void => {\n    recordOwner(step.key, resolveFragmentId(step.key))\n    if (step.kind !== 'call') return\n    for (const inner of step.onSuccess) recordOwners(inner, resolveFragmentId)\n    for (const inner of step.onFailure) recordOwners(inner, resolveFragmentId)\n  }\n\n  for (const part of parts) {\n    if (isReadonlyArray(part)) {\n      steps.push(...part)\n      for (const step of part) recordOwners(step, () => undefined)\n      continue\n    }\n\n    // fragment / composeResult (both carry `steps`)\n    const partSteps = part.steps\n    steps.push(...partSteps)\n\n    const partSources = part.sources\n    if (partSources && typeof partSources === 'object') {\n      for (const k of Object.keys(partSources).sort()) {\n        sources[k] = { ...partSources[k]! }\n      }\n    }\n\n    const fragmentId = 'fragmentId' in part ? part.fragmentId : undefined\n    if (typeof fragmentId === 'string' && fragmentId.length > 0) {\n      for (const step of partSteps as ReadonlyArray<WorkflowStepV1>) {\n        recordSourcesForFragment(sources, fragmentId, step)\n      }\n    }\n\n    const resolveFragmentIdForPart = (stepKey: string): string | undefined => {\n      if (typeof fragmentId === 'string' && fragmentId.length > 0) return fragmentId\n      const fromSources = partSources?.[stepKey]?.fragmentId\n      return typeof fromSources === 'string' && fromSources.length > 0 ? fromSources : undefined\n    }\n    for (const step of partSteps) recordOwners(step, resolveFragmentIdForPart)\n\n    policy = mergePolicy(policy, part.policy)\n  }\n\n  const finalSources: WorkflowDefV1['sources'] | undefined = Object.keys(sources).length > 0 ? sources : undefined\n  const duplicateKeys = Array.from(ownersByKey.entries())\n    .filter(([, owners]) => owners.length > 1)\n    .map(([k]) => k)\n    .sort()\n  if (duplicateKeys.length > 0) {\n    const k = duplicateKeys[0]!\n    throw makeWorkflowError({\n      code: 'WORKFLOW_DUPLICATE_STEP_KEY',\n      message: `Duplicate stepKey \"${k}\" detected during composition.`,\n      source: { stepKey: k },\n      detail: { duplicateKey: k, owners: ownersByKey.get(k) ?? [] },\n    })\n  }\n\n  return {\n    steps,\n    ...(finalSources ? { sources: finalSources } : null),\n    ...(policy ? { policy } : null),\n  }\n}\n\nexport const make = <M = unknown>(input: {\n  readonly astVersion?: 1\n  readonly localId: string\n  readonly trigger: WorkflowTrigger<ActionTagsOfModule<M>>\n  readonly policy?: WorkflowPolicyV1\n  readonly steps: WorkflowStepsInput<ActionTagsOfModule<M>>\n  readonly meta?: { readonly generator?: JsonValue }\n}): Workflow => {\n  const localId = asNonEmptyString(input.localId)\n  if (!localId) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_INVALID_DEF',\n      message: 'Workflow.make: localId must be a non-empty string.',\n      detail: { localId: input.localId },\n    })\n  }\n\n  const stepsInput = resolveStepsInput(input.steps)\n  const merged = mergePolicy(input.policy, stepsInput.policy)\n\n  const def: WorkflowDefV1 = normalizeWorkflowDefV1({\n    astVersion: 1,\n    localId,\n    trigger: input.trigger,\n    ...(merged ? { policy: merged } : null),\n    steps: stepsInput.steps,\n    ...(stepsInput.sources ? { sources: stepsInput.sources } : null),\n    ...(input.meta ? { meta: input.meta } : null),\n  })\n\n  const staticIrCache = new Map<string, WorkflowStaticIrV1>()\n\n  return {\n    _tag: 'Workflow',\n    def,\n    toJSON: () => def,\n    validate: () => validateWorkflowDefV1(def),\n    exportStaticIr: (moduleId) => {\n      const cached = staticIrCache.get(moduleId)\n      if (cached) return cached\n      const ir = compileWorkflowStaticIrV1({ moduleId, def })\n      staticIrCache.set(moduleId, ir)\n      return ir\n    },\n    install: (moduleTag) =>\n      WorkflowRuntime.installOne({\n        moduleTag: moduleTag as unknown as Parameters<typeof WorkflowRuntime.installOne>[0]['moduleTag'],\n        program: { _tag: 'Workflow', def },\n      }),\n  } satisfies Workflow\n}\n\nexport const fromJSON = <ActionTag extends string = string>(def: WorkflowDef<ActionTag>): Workflow =>\n  make({\n    localId: def.localId,\n    trigger: def.trigger,\n    ...(def.policy ? { policy: def.policy } : null),\n    steps: {\n      steps: def.steps,\n      ...(def.sources ? { sources: def.sources } : null),\n    },\n    ...(def.meta ? { meta: def.meta } : null),\n  })\n", "import type { Context } from 'effect'\n\n/**\n * ServiceId contract (specs/078-module-service-manifest/contracts/service-id.md):\n * - Stable string derived from Context.Tag by priority: tag.key ?? tag.id ?? tag._id\n * - tag.toString() is forbidden as an identity source (diagnostics only).\n */\n\nexport type ServiceId = string\n\nconst asNonEmptyString = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.length > 0 ? value : undefined\n\nexport const fromTag = (tag: Context.Tag<any, any>): ServiceId | undefined => {\n  const anyTag = tag as any\n  return asNonEmptyString(anyTag.key) ?? asNonEmptyString(anyTag.id) ?? asNonEmptyString(anyTag._id)\n}\n\nexport const requireFromTag = (tag: Context.Tag<any, any>, options?: { readonly hint?: string }): ServiceId => {\n  const id = fromTag(tag)\n  if (id) return id\n\n  const hint =\n    options?.hint ??\n    'Define the Tag with a stable string key, e.g. `class X extends Context.Tag(\"my-svc/x\")<X, Service>() {}`.'\n\n  throw new Error(`[InvalidServiceId] Tag is missing a stable id (tag.key/tag.id/tag._id).\\n${hint}`)\n}\n"],
  "mappings": "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",
  "names": ["asNonEmptyString"]
}
