workflow-studio

packages/workflow-studio/
├── src/
│   ├── adapters/
│   │   ├── common.ts           # Config resolution and proxy utilities
│   │   ├── common.test.ts      # Config resolution tests
│   │   └── types.ts            # TypeScript interfaces
│   ├── topology/
│   │   ├── execution-adapters.ts   # Local vs Remote execution
│   │   ├── queue-adapters.ts       # Queue backend factories
│   │   ├── stream-adapters.ts      # Stream backend factories
│   │   └── types.ts                # Topology type definitions
│   ├── config.ts               # defineWorkflowStudioConfig helper
│   ├── next.ts                 # Next.js framework adapter
│   ├── nitro.ts                # Nitro framework adapter
│   ├── sveltekit.ts            # SvelteKit framework adapter
│   ├── cli.ts                  # CLI implementation
│   ├── cli.test.ts             # CLI tests
│   ├── ownership.ts            # Diagnostics handler
│   └── index.ts                # Public exports
├── world-remote.cjs            # Remote world implementation
├── remote-ownership-state.cjs  # Global state for ownership tracking
└── package.json

// src/adapters/common.ts
export async function resolveWorkflowStudioAdapterConfig(
  config?: WorkflowStudioAdapterConfig,
  options: ResolveAdapterConfigOptions = {}
): Promise<ResolvedWorkflowStudioAdapterConfig> {
  const fileConfig = await loadWorkflowStudioConfig(cwd);

  const remoteBaseUrl = normalizeBaseUrl(
    config?.remote?.baseUrl ??        // 1. Adapter options
      remoteFromFile?.baseUrl ??       // 2. Config file
      env.WORKFLOW_COMPUTE_BASE_URL    // 3. Environment
  );

  // Similar precedence for execution mode, API key, etc.
}

export async function loadWorkflowStudioConfig(
  cwd = process.cwd()
): Promise<WorkflowStudioConfig | undefined> {
  const candidates = [
    'workflow.config.mjs',
    'workflow.config.js',
    'workflow.config.cjs',
    'workflow.config.ts',
    'workflow.config.mts',
    'workflow.config.cts',
  ].map((name) => resolve(cwd, name));

  // Try each until one succeeds
}

// src/next.ts
export async function withWorkflowStudioNext<T extends NextConfigLike>(
  nextConfig: T,
  options: WorkflowStudioNextOptions = {}
): Promise<T> {
  const resolved = await resolveWorkflowStudioAdapterConfig(options, options);
  const serverDefaults = getServerEnvDefaults(resolved);

  return {
    ...nextConfig,
    workflowStudio: {  // NOT nextConfig.env (client-exposed)
      ...(nextConfig.workflowStudio ?? {}),
      ...serverDefaults,
    },
  };
}

// src/nitro.ts
return {
  ...nitroConfig,
  runtimeConfig: {
    ...(nitroConfig.runtimeConfig ?? {}),
    workflowStudio: {
      ...((nitroConfig.runtimeConfig?.workflowStudio as Record<string, unknown>) ?? {}),
      ...serverDefaults,
    },
  },
};

// src/sveltekit.ts
return {
  ...config,
  kit: {
    ...(config.kit ?? {}),
    env: {
      ...(config.kit?.env ?? {}),
      workflowStudio: {
        ...((config.kit?.env as Record<string, unknown> | undefined)?.workflowStudio ?? {}),
        ...serverDefaults,
      },
    },
  },
};

// src/adapters/common.ts
export async function proxyTrigger(
  input: TriggerProxyInput,
  context: ProxyContext = {}
): Promise<ComputeTriggerResponse> {
  const resolved = await resolveWorkflowStudioAdapterConfig(context.config, {
    cwd: context.cwd,
    env,
  });

  if (!resolved.remote.baseUrl) {
    throw new Error('Remote compute is not configured...');
  }
  if (resolved.mode !== 'proxy-trigger') {
    throw new Error(`proxyTrigger requires mode=proxy-trigger...`);
  }

  const client = createClient(resolved, env);
  return await client.trigger(input.payload, { idempotencyKey });
}

// src/adapters/common.ts
function ensureRemoteWorldTargetGuard(
  executionMode: 'local' | 'remote',
  remoteWorldTarget: string,
  env: NodeJS.ProcessEnv
): void {
  if (executionMode !== 'remote' || !shouldApplyStrictRemoteGuard(env)) {
    return;
  }

  const currentTarget = env.WORKFLOW_TARGET_WORLD;
  if (currentTarget !== remoteWorldTarget) {
    throw new Error(
      `Remote execution guard failed: set WORKFLOW_TARGET_WORLD=${remoteWorldTarget}...`
    );
  }
}

// src/cli.ts
export async function runWorkflowStudioCli(argv: string[]): Promise<void> {
  const [scope, command, ...rest] = argv;

  if (scope !== 'compute' || !command) {
    console.log(usage());
    return;
  }

  switch (command) {
    case 'build':
      await cmdComputeBuild(rest);
      return;
    case 'deploy':
      await cmdComputeDeploy(rest);
      return;
    // ...
  }
}

// world-remote.cjs
function createWorld() {
  return {
    async getDeploymentId() {
      const response = await requestJson('/v1/world/deployment-id', {
        method: 'GET',
      });
      return response.deploymentId;
    },

    async queue(queueName, message, opts) {
      return await requestJson('/v1/queue/publish', {
        method: 'POST',
        body: JSON.stringify({ queueName, message, opts }),
      });
    },

    createQueueHandler() {
      // Returns 409 guardrail response
    },

    // ... runs, steps, events, hooks, streams
  };
}