System Architecture

const initialView = yield* Effect.sync(() => UserConfigView.make(initialRawConfig)).pipe(
  Effect.tapError((error) => Effect.logError("Failed to create initial config view", error)),
  Effect.mapError((error) => new ConfigViewCreateError({ cause: error })),
);

Request A ──┐
Request B ──┼──> Package Service ──> Single API Call
Request C ──┘

const getOrSetEither = <A, E, R>(opts: GetOrSetOptions<A, E, R>) =>
  Effect.suspend(() => {
    const keyHash = hash(opts.key);
    const key = opts.namespace ? `${opts.namespace}:${keyHash}` : keyHash;

    let deferred = MutableHashMap.get<string, Deferred.Deferred<A, E>>(inflight, key).pipe(
      Option.getOrUndefined,
    );

    if (deferred === undefined) {
      // First request - create deferred and fetch
      deferred = Deferred.unsafeMake<A, E>(fiberId);
      MutableHashMap.set(inflight, key, deferred);
      // ... fetch logic
    } else {
      // Subsequent requests - wait for deferred
      return Effect.gen(function* () {
        stats.track("deferred");
        return yield* Effect.either(Deferred.await(deferred!));
      });
    }
  });

1. File System (YAML)
   ↓
2. File Watcher (chokidar) detects change
   ↓
3. Config Adapter parses file
   ↓
4. Effect Schema validates
   ↓
5. Individual errors isolated → Warnings
   ↓
6. UserConfigView aggregates all configs
   ↓
7. SubscriptionRef updated
   ↓
8. SSE broadcasts to clients
   ↓
9. Client updates reactive state
   ↓
10. UI re-renders

1. Client requests package by hash
   ↓
2. Package Service validates hash exists in config
   ↓
3. Cache lookup (L1 → L2)
   ↓
4. Cache miss → Request coalescing check
   ↓
5. Provider adapter fetches from external API
   ↓
6. Response cached (success or not-found)
   ↓
7. Response returned to client

shipped/
├── app/                    # Vue application (components, pages, composables)
├── layers/                 # Nuxt layers (01-base/, 02-packages/)
├── libs/                   # Shared business logic (client + server safe)
│   ├── config/            # Config schemas and view classes
│   ├── packages/          # Package types and schemas
│   └── utils/             # General utilities
├── server/                 # Backend code (Effect TS)
│   ├── providers/         # External provider adapters
│   ├── services/          # Business services
│   └── rpc/               # RPC route handlers
├── shared/                 # Client boundary - re-exports from libs
└── config/                 # User configuration files (YAML)

export class UserConfigService extends Effect.Service<UserConfigService>()(
  "userconfig-service",
  {
    accessors: true,
    scoped: Effect.gen(function* () {
      const loader = yield* UserConfigLoader;
      const { config } = loader;
      
      const initialRawConfig = yield* config.get;
      const initialView = yield* Effect.sync(() => UserConfigView.make(initialRawConfig));
      const configView = yield* SubscriptionRef.make<UserConfigView>(initialView);
      
      return {
        config,
        configView,
      };
    }),
  }
) {}

export type ProviderError = 
  | PackageNotFoundError 
  | NetworkError 
  | InvalidPackageNameError;

export type PackageProvider<T extends ProviderInfo = ProviderInfo> = {
  readonly getPackage: (
    opts: PackageConfigView
  ) => Effect.Effect<Package, ProviderError>;
};

const stream = Stream.asyncScoped<{ event: Events; path: string }, unknown>((emit) =>
  Effect.acquireRelease(
    Effect.sync(() => {
      const watcher = chokidar.watch(paths, opts);
      watcher.on("all", (event, path) => {
        emit(Effect.succeed(Chunk.make({ event, path })));
      });
      return watcher;
    }),
    (watcher) =>
      Effect.promise(async () => {
        watcher.removeAllListeners();
        await watcher.close();
      })
  )
);