@playfast/muxmaxing-config 0.1.2 → 0.2.0

package/package.json

@@ -1,34 +1,37 @@
 {
   "name": "@playfast/muxmaxing-config",
-  "version": "0.1.2",
-  "type": "module",
+  "version": "0.2.0",
   "description": "Author API for muxmaxing.config.ts — a repo-committed hook bridge between the host device and muxmaxing work units: typed host-input collection plus Effect-native lifecycle hooks (machine created, new terminal, removed) with bash bridged into the unit.",
   "keywords": [
-    "muxmaxing",
+    "devcontainer",
     "effect",
     "hooks",
-    "devcontainer",
+    "muxmaxing",
     "provisioning"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/muxmaxing-config"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./*": "./src/*.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -36,13 +39,10 @@
     "lint": "oxlint src",
     "lint:fix": "oxlint --fix src"
   },
-  "peerDependencies": {
-    "effect": "*"
-  },
   "devDependencies": {
     "@types/bun": "^1.3.14"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "effect": "*"
   }
 }

package/src/index.ts

@@ -66,8 +66,7 @@ export interface MuxmaxingConfigExternalApi<A, I> {
 
 export type MuxmaxingConfig<A, I> = MuxmaxingConfigExternalApi<A, I>
 
-export const defineConfig = <A, I>(config: MuxmaxingConfig<A, I>): MuxmaxingConfig<A, I> =>
-  config
+export const defineConfig = <A, I>(config: MuxmaxingConfig<A, I>): MuxmaxingConfig<A, I> => config
 
 export const isMuxmaxingConfig = (
   candidate: unknown,

package/src/protocol.ts

@@ -31,8 +31,10 @@ export const BashOk: S.TaggedStruct<
 > = S.TaggedStruct('BashOk', { stdout: S.String, stderr: S.String, exitCode: S.Number })
 export type BashOk = typeof BashOk.Type
 
-export const BashFailed: S.TaggedStruct<'BashFailed', { reason: typeof S.String }> =
-  S.TaggedStruct('BashFailed', { reason: S.String })
+export const BashFailed: S.TaggedStruct<'BashFailed', { reason: typeof S.String }> = S.TaggedStruct(
+  'BashFailed',
+  { reason: S.String },
+)
 export type BashFailed = typeof BashFailed.Type
 
 export const BashReply: S.TaggedStruct<
@@ -61,18 +63,19 @@ export const BashRequest: S.TaggedStruct<
 })
 export type BashRequest = typeof BashRequest.Type
 
-export const LogMessage: S.TaggedStruct<'Log', { line: typeof S.String }> = S.TaggedStruct(
-  'Log',
-  { line: S.String },
-)
+export const LogMessage: S.TaggedStruct<'Log', { line: typeof S.String }> = S.TaggedStruct('Log', {
+  line: S.String,
+})
 export type LogMessage = typeof LogMessage.Type
 
 export const HookDone: S.TaggedStruct<'HookDone', { hostInput: S.NullOr<typeof S.Unknown> }> =
   S.TaggedStruct('HookDone', { hostInput: S.NullOr(S.Unknown) })
 export type HookDone = typeof HookDone.Type
 
-export const HookFailed: S.TaggedStruct<'HookFailed', { reason: typeof S.String }> =
-  S.TaggedStruct('HookFailed', { reason: S.String })
+export const HookFailed: S.TaggedStruct<'HookFailed', { reason: typeof S.String }> = S.TaggedStruct(
+  'HookFailed',
+  { reason: S.String },
+)
 export type HookFailed = typeof HookFailed.Type
 
 export const WorkerToEngine: S.Union<

package/src/worker-entry.ts

@@ -1,4 +1,5 @@
 import { Cause, Data, Effect, Either, Match, Option, Ref, Schema as S } from 'effect'
+import { parentPort } from 'node:worker_threads'
 import {
   type BashReply,
   BashRequest,
@@ -8,7 +9,7 @@ import {
   LogMessage,
   type RunHookRequest,
   WorkerToEngine,
-} from './protocol'
+} from '@playfast/muxmaxing-config/protocol'
 import {
   type BashResult,
   HookBashError,
@@ -16,10 +17,12 @@ import {
   isMuxmaxingConfig,
   type MuxmaxingConfig,
   type UnitInfo,
-} from './index'
+} from '@playfast/muxmaxing-config'
 
 declare const self: Worker
 
+const hasWebWorkerScope = typeof self !== 'undefined'
+
 class WorkerHookError extends Data.TaggedError('WorkerHookError')<{
   readonly reason: string
 }> {
@@ -30,7 +33,16 @@ class WorkerHookError extends Data.TaggedError('WorkerHookError')<{
 }
 
 const send = (message: WorkerToEngine): void => {
-  self.postMessage(S.encodeSync(WorkerToEngine)(message))
+  const encoded = S.encodeSync(WorkerToEngine)(message)
+  if (hasWebWorkerScope) {
+    self.postMessage(encoded)
+    return
+  }
+  if (parentPort !== null) {
+    parentPort.postMessage(encoded)
+    return
+  }
+  Effect.runSync(Effect.dieMessage('worker entry has no parent message port'))
 }
 
 const describe = (cause: unknown): string =>
@@ -54,8 +66,7 @@ const makeBridgedBash =
                       stderr: ok.stderr,
                       exitCode: ok.exitCode,
                     }),
-                  BashFailed: (failed) =>
-                    Effect.fail(new HookBashError({ reason: failed.reason })),
+                  BashFailed: (failed) => Effect.fail(new HookBashError({ reason: failed.reason })),
                 }),
                 Match.exhaustive,
               ),
@@ -74,18 +85,14 @@ const loadConfig = (
 ): Effect.Effect<MuxmaxingConfig<unknown, unknown>, WorkerHookError> =>
   Effect.tryPromise({
     try: (): Promise<unknown> => import(configPath),
-    catch: (cause) =>
-      new WorkerHookError({ reason: `config import failed: ${describe(cause)}` }),
+    catch: (cause) => new WorkerHookError({ reason: `config import failed: ${describe(cause)}` }),
   }).pipe(
     Effect.flatMap((moduleExports) => {
       const record: Record<string, unknown> =
-        typeof moduleExports === 'object' && moduleExports !== null
-          ? { ...moduleExports }
-          : {}
+        typeof moduleExports === 'object' && moduleExports !== null ? { ...moduleExports } : {}
       const defaulted = Option.fromNullable(record['default'])
       return Option.match(defaulted, {
-        onNone: () =>
-          Effect.fail(new WorkerHookError({ reason: 'config has no default export' })),
+        onNone: () => Effect.fail(new WorkerHookError({ reason: 'config has no default export' })),
         onSome: (config) => {
           if (isMuxmaxingConfig(config)) {
             return Effect.succeed(config)
@@ -116,80 +123,80 @@ const hookFailure =
   (cause: unknown): WorkerHookError =>
     new WorkerHookError({ reason: `${hookName} failed: ${describe(cause)}` })
 
-const runRequested = Effect.fn('runRequested')(
-  function* (request: RunHookRequest): Effect.fn.Return<HookDone, WorkerHookError> {
-    const config = yield* loadConfig(request.configPath)
-    const idRef = yield* Ref.make(0)
-    const unit: UnitInfo = {
-      id: request.unit.id,
-      workspaceFolder: request.unit.workspaceFolder,
-    }
-    const host: HostBridge = { bash: makeBridgedBash(idRef, 'host'), env: Bun.env }
-    const unitBridge = { ...unit, bash: makeBridgedBash(idRef, 'unit') }
-
-    // Undefined consuming hooks are intentional silent no-ops.
-    const runOptional = <Ctx>(
-      hookName: string,
-      hook: ((ctx: Ctx) => Effect.Effect<void, unknown>) | undefined,
-      makeCtx: (hostInput: unknown) => Ctx,
-    ): Effect.Effect<HookDone, WorkerHookError> =>
-      Option.match(Option.fromNullable(hook), {
-        onNone: () => Effect.succeed(HookDone.make({ hostInput: null })),
-        onSome: (run) =>
-          decodeHostInput(config, request.hostInput).pipe(
-            Effect.flatMap((hostInput) =>
-              run(makeCtx(hostInput)).pipe(Effect.mapError(hookFailure(hookName))),
-            ),
-            Effect.map(() => HookDone.make({ hostInput: null })),
+const runRequested = Effect.fn('runRequested')(function* (
+  request: RunHookRequest,
+): Effect.fn.Return<HookDone, WorkerHookError> {
+  const config = yield* loadConfig(request.configPath)
+  const idRef = yield* Ref.make(0)
+  const unit: UnitInfo = {
+    id: request.unit.id,
+    workspaceFolder: request.unit.workspaceFolder,
+  }
+  const workerEnv = typeof Bun === 'undefined' ? process.env : Bun.env
+  const host: HostBridge = { bash: makeBridgedBash(idRef, 'host'), env: workerEnv }
+  const unitBridge = { ...unit, bash: makeBridgedBash(idRef, 'unit') }
+
+  // Undefined consuming hooks are intentional silent no-ops.
+  const runOptional = <Ctx>(
+    hookName: string,
+    hook: ((ctx: Ctx) => Effect.Effect<void, unknown>) | undefined,
+    makeCtx: (hostInput: unknown) => Ctx,
+  ): Effect.Effect<HookDone, WorkerHookError> =>
+    Option.match(Option.fromNullable(hook), {
+      onNone: () => Effect.succeed(HookDone.make({ hostInput: null })),
+      onSome: (run) =>
+        decodeHostInput(config, request.hostInput).pipe(
+          Effect.flatMap((hostInput) =>
+            run(makeCtx(hostInput)).pipe(Effect.mapError(hookFailure(hookName))),
           ),
-      })
+          Effect.map(() => HookDone.make({ hostInput: null })),
+        ),
+    })
 
-    return yield* Match.value(request.hook).pipe(
-      Match.when('collect', () =>
-        config
-          .collectHostDeviceInput({ host, unit, log })
-          .pipe(
-            Effect.mapError(hookFailure('collectHostDeviceInput')),
-            Effect.flatMap((collected) =>
-              S.encodeUnknown(config.hostInput)(collected).pipe(
-                Effect.mapError(
-                  (issue) =>
-                    new WorkerHookError({
-                      reason: `hostInput encode failed: ${String(issue)}`,
-                    }),
-                ),
-              ),
+  return yield* Match.value(request.hook).pipe(
+    Match.when('collect', () =>
+      config.collectHostDeviceInput({ host, unit, log }).pipe(
+        Effect.mapError(hookFailure('collectHostDeviceInput')),
+        Effect.flatMap((collected) =>
+          S.encodeUnknown(config.hostInput)(collected).pipe(
+            Effect.mapError(
+              (issue) =>
+                new WorkerHookError({
+                  reason: `hostInput encode failed: ${String(issue)}`,
+                }),
             ),
-            Effect.map((encoded) => HookDone.make({ hostInput: encoded ?? null })),
           ),
+        ),
+        Effect.map((encoded) => HookDone.make({ hostInput: encoded ?? null })),
       ),
-      Match.when('machineCreated', () =>
-        runOptional('onWorkUnitMachineCreated', config.onWorkUnitMachineCreated, (hostInput) => ({
-          hostInput,
-          host,
-          unit: unitBridge,
-          log,
-        })),
-      ),
-      Match.when('newTerminal', () =>
-        runOptional('onNewTerminal', config.onNewTerminal, (hostInput) => ({
-          hostInput,
-          host,
-          unit: unitBridge,
-          log,
-        })),
-      ),
-      Match.when('removed', () =>
-        runOptional('onWorkUnitRemoved', config.onWorkUnitRemoved, (hostInput) => ({
-          hostInput,
-          host,
-          unit,
-          log,
-        })),
-      ),
-      Match.exhaustive,
-    )
-  })
+    ),
+    Match.when('machineCreated', () =>
+      runOptional('onWorkUnitMachineCreated', config.onWorkUnitMachineCreated, (hostInput) => ({
+        hostInput,
+        host,
+        unit: unitBridge,
+        log,
+      })),
+    ),
+    Match.when('newTerminal', () =>
+      runOptional('onNewTerminal', config.onNewTerminal, (hostInput) => ({
+        hostInput,
+        host,
+        unit: unitBridge,
+        log,
+      })),
+    ),
+    Match.when('removed', () =>
+      runOptional('onWorkUnitRemoved', config.onWorkUnitRemoved, (hostInput) => ({
+        hostInput,
+        host,
+        unit,
+        log,
+      })),
+    ),
+    Match.exhaustive,
+  )
+})
 
 const handleRunHook = (request: RunHookRequest): void => {
   void Effect.runPromise(
@@ -201,15 +208,21 @@ const handleRunHook = (request: RunHookRequest): void => {
       // Drop the listener so the event loop drains and the worker exits.
       Effect.ensuring(
         Effect.sync(() => {
-          self.onmessage = null
+          if (hasWebWorkerScope) {
+            self.onmessage = null
+            return
+          }
+          if (parentPort !== null) {
+            parentPort.close()
+          }
         }),
       ),
     ),
   )
 }
 
-self.onmessage = (event: MessageEvent): void => {
-  Either.match(S.decodeUnknownEither(EngineToWorker)(event.data), {
+const handleMessage = (payload: unknown): void => {
+  Either.match(S.decodeUnknownEither(EngineToWorker)(payload), {
     onLeft: () => send(HookFailed.make({ reason: 'undecodable engine message' })),
     onRight: (message) =>
       Match.value(message).pipe(
@@ -225,3 +238,13 @@ self.onmessage = (event: MessageEvent): void => {
       ),
   })
 }
+
+if (hasWebWorkerScope) {
+  self.onmessage = (event: MessageEvent): void => handleMessage(event.data)
+}
+if (!hasWebWorkerScope && parentPort !== null) {
+  parentPort.on('message', handleMessage)
+}
+if (!hasWebWorkerScope && parentPort === null) {
+  Effect.runSync(Effect.dieMessage('worker entry has no parent message port'))
+}