Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import * as BrowserWorker from '@effect/platform-browser/BrowserWorker';
import * as BrowserWorkerRunner from '@effect/platform-browser/BrowserWorkerRunner';
import * as Cause from 'effect/Cause';
import * as Effect from 'effect/Effect';
import * as Fiber from 'effect/Fiber';
import * as Queue from 'effect/Queue';
import * as WorkerApi from 'effect/unstable/workers/Worker';
import type { WorkerError } from 'effect/unstable/workers/WorkerError';
export type BrowserWorkerEndpoint = Worker | SharedWorker | MessagePort;
/** Effect's parent-to-runner request frame tag. */
export const EFFECT_WORKER_REQUEST_TAG = 0 as const;
/** Effect's runner-to-parent ready frame. */
export const EFFECT_WORKER_READY_FRAME = [EFFECT_WORKER_REQUEST_TAG] as const;
/** Effect's runner-to-parent response frame tag. */
export const EFFECT_WORKER_RESPONSE_TAG = 1 as const;
/** Effect's parent-to-runner close frame. */
export const EFFECT_WORKER_CLOSE_FRAME = [EFFECT_WORKER_RESPONSE_TAG] as const;
/** The browser replaced the runner global without replacing the page's port. */
export class WorkerRestartedError extends Error {
constructor() {
super('Effect worker transport restarted');
this.name = 'WorkerRestartedError';
}
}
export interface EffectWorkerTransportOptions<Inbound> {
/** Existing browser endpoint. Its lifetime remains owned by the caller. */
endpoint: BrowserWorkerEndpoint;
onMessage(message: Inbound): void;
onError(error: Error): void;
/** Synchronously closes the caller-owned browser endpoint. */
closeEndpoint?: () => void;
}
export interface EffectWorkerTransport<Outbound> {
/** Resolves after the runner has installed its receive loop. */
readonly ready: Promise<void>;
/** Sends through Effect's worker protocol, including optional transferables. */
send(
message: Outbound,
transfers?: readonly Transferable[]
): Effect.Effect<void, Error>;
/** Closes the Effect scope and then the caller-owned browser endpoint. */
close(): Effect.Effect<void>;
}
const asError = (cause: unknown): Error =>
cause instanceof Error ? cause : new Error(String(cause));
const originalWorkerError = (error: WorkerError): Error =>
error.reason.cause instanceof Error ? error.reason.cause : error;
/**
* Starts Effect's parent-side browser worker protocol over an existing worker
* endpoint while keeping endpoint construction and termination with the cache
* ownership topology.
*/
export function createEffectWorkerTransport<Inbound, Outbound>(
options: EffectWorkerTransportOptions<Inbound>
): EffectWorkerTransport<Outbound> {
const backing = Effect.runSync(
Effect.gen(function* () {
const platform = yield* WorkerApi.WorkerPlatform;
return yield* platform.spawn<Inbound, Outbound>(0);
}).pipe(Effect.provide(BrowserWorker.layer(() => options.endpoint)))
);
let readySettled = false;
let receivedReady = false;
let closed = false;
let resolveReady!: () => void;
let rejectReady!: (error: Error) => void;
const ready = new Promise<void>((resolve, reject) => {
resolveReady = resolve;
rejectReady = reject;
});
const reportFailure = (error: Error): void => {
if (!readySettled) {
readySettled = true;
rejectReady(error);
}
options.onError(error);
};
const run = backing
.run(
(message) =>
Effect.sync(() => {
options.onMessage(message);
}),
{
onSpawn: Effect.sync(() => {
if (closed) return;
// Safari can reconnect this same port to an empty SharedWorker
// global. Its old registrations and engine route no longer exist.
if (receivedReady) {
reportFailure(new WorkerRestartedError());
return;
}
receivedReady = true;
// Effect invokes `onSpawn` before opening its private ready latch.
// Resolving synchronously here lets awaiters run before buffered sends
// flush (covered by the transport ordering test), so defer one task.
setTimeout(() => {
if (readySettled) return;
readySettled = true;
resolveReady();
}, 0);
}),
}
)
.pipe(
Effect.catchCause((cause) =>
Effect.sync(() => {
if (!closed) reportFailure(asError(Cause.squash(cause)));
})
)
);
const messageTarget =
'port' in options.endpoint ? options.endpoint.port : options.endpoint;
const onMessageError: EventListener = (event): void => {
reportFailure(
new Error('Effect worker transport messageerror', {
cause: (event as MessageEvent).data,
})
);
};
messageTarget.addEventListener('messageerror', onMessageError);
const fiber = Effect.runFork(run);
return {
ready,
send(message, transfers): Effect.Effect<void, Error> {
return Effect.suspend(() => {
if (closed) {
return Effect.fail(new Error('Effect worker transport is closed'));
}
return backing
.send(message, transfers)
.pipe(Effect.mapError(originalWorkerError));
});
},
close(): Effect.Effect<void> {
return Effect.suspend(() => {
if (!closed) {
closed = true;
if (!readySettled) {
readySettled = true;
rejectReady(
new Error('Effect worker transport closed before ready')
);
}
messageTarget.removeEventListener('messageerror', onMessageError);
// Preserve the browser adapter's synchronous endpoint teardown while
// still speaking Effect's explicit close protocol to the runner.
try {
messageTarget.postMessage(EFFECT_WORKER_CLOSE_FRAME);
} catch {
// Endpoint teardown remains authoritative if close framing fails.
} finally {
options.closeEndpoint?.();
}
}
return Fiber.interrupt(fiber);
});
},
};
}
export interface EffectWorkerRunnerOptions<Inbound> {
endpoint: MessagePort | Window;
onMessage(portId: number, message: Inbound): void | Promise<void>;
onDisconnect?: (portId: number) => void;
onError(error: Error): void;
/** Releases router state when the runner exits, including a peer close frame. */
onClose?: () => void;
}
export interface EffectWorkerRunnerTransport<Outbound> {
send(
portId: number,
message: Outbound,
transfers?: readonly Transferable[]
): Effect.Effect<void, Error>;
isClosed(): boolean;
close(): Effect.Effect<void>;
}
/** Runs Effect's worker-side protocol over a worker global or explicit port. */
export function createEffectWorkerRunnerTransport<Inbound, Outbound>(
options: EffectWorkerRunnerOptions<Inbound>
): EffectWorkerRunnerTransport<Outbound> {
const platform = BrowserWorkerRunner.make(options.endpoint);
const runner = Effect.runSync(platform.start<Outbound, Inbound>());
let closed = false;
const run = runner
.run((portId, message) => {
const handled = options.onMessage(portId, message);
return handled instanceof Promise
? Effect.promise(() => handled)
: undefined;
})
.pipe(
Effect.catchCause((cause) =>
Effect.sync(() => {
if (!closed) options.onError(asError(Cause.squash(cause)));
})
)
);
const fiber = Effect.runFork(run);
const disconnectFiber = runner.disconnects
? Effect.runFork(
Queue.take(runner.disconnects).pipe(
Effect.tap((portId) =>
Effect.sync(() => options.onDisconnect?.(portId))
),
Effect.forever
)
)
: undefined;
fiber.addObserver(() => {
closed = true;
if (disconnectFiber) Effect.runFork(Fiber.interrupt(disconnectFiber));
options.onClose?.();
});
return {
send(portId, message, transfers): Effect.Effect<void, Error> {
return Effect.suspend(() => {
if (closed) {
return Effect.fail(
new Error('Effect worker runner transport is closed')
);
}
return runner.send(portId, message, transfers);
});
},
isClosed(): boolean {
return closed;
},
close(): Effect.Effect<void> {
return Effect.suspend(() => {
closed = true;
return Effect.all(
[
Fiber.interrupt(fiber),
...(disconnectFiber ? [Fiber.interrupt(disconnectFiber)] : []),
],
{ discard: true }
);
});
},
};
}
/** Extracts Effect's typed worker failure for telemetry without exposing Effect. */
export function effectWorkerErrorTag(
error: unknown
): WorkerError['reason']['_tag'] | undefined {
if (
typeof error !== 'object' ||
error === null ||
!('reason' in error) ||
typeof error.reason !== 'object' ||
error.reason === null ||
!('_tag' in error.reason)
) {
return undefined;
}
const tag = error.reason._tag;
return tag === 'WorkerSpawnError' ||
tag === 'WorkerSendError' ||
tag === 'WorkerReceiveError' ||
tag === 'WorkerUnknownError'
? tag
: undefined;
}