@rikalabs/effect-react 0.0.1

package/dist/testing/index.cjs

@@ -0,0 +1,970 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  createTestApp: () => createTestApp
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/actions/service.ts
+var import_effect3 = require("effect");
+
+// src/boundary/codecs.ts
+var import_effect = require("effect");
+
+// src/boundary/errors.ts
+var BoundaryDecodeError = class extends Error {
+  constructor(source, messageText, causeValue) {
+    super(`Boundary decode failed at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "BoundaryDecodeError";
+  }
+  _tag = "BoundaryDecodeError";
+};
+var BoundaryTransportError = class extends Error {
+  constructor(source, messageText, causeValue) {
+    super(`Boundary transport failed at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "BoundaryTransportError";
+  }
+  _tag = "BoundaryTransportError";
+};
+var BoundaryProtocolError = class extends Error {
+  constructor(source, messageText) {
+    super(`Boundary protocol violation at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.name = "BoundaryProtocolError";
+  }
+  _tag = "BoundaryProtocolError";
+};
+
+// src/boundary/codecs.ts
+var Boundary = class extends import_effect.Context.Tag("EffectReact/Boundary")() {
+};
+var parseErrorMessage = (error) => import_effect.Cause.pretty(import_effect.Cause.fail(error)).trim();
+var makeBoundaryService = () => ({
+  decodeUnknown: ({ source, schema, value }) => import_effect.Schema.decodeUnknown(schema)(value).pipe(
+    import_effect.Effect.mapError(
+      (error) => new BoundaryDecodeError(source, parseErrorMessage(error), error)
+    )
+  ),
+  decodeTextJson: ({ source, schema, text }) => import_effect.Effect.gen(function* () {
+    const payload = yield* import_effect.Effect.try({
+      try: () => JSON.parse(text),
+      catch: (cause) => new BoundaryTransportError(source, "failed to parse JSON payload", cause)
+    });
+    return yield* import_effect.Schema.decodeUnknown(schema)(payload).pipe(
+      import_effect.Effect.mapError(
+        (error) => new BoundaryDecodeError(source, parseErrorMessage(error), error)
+      )
+    );
+  }),
+  encode: ({ source, schema, value }) => import_effect.Schema.encode(schema)(value).pipe(
+    import_effect.Effect.mapError((error) => new BoundaryProtocolError(source, parseErrorMessage(error)))
+  )
+});
+var BoundaryLive = import_effect.Layer.succeed(Boundary, makeBoundaryService());
+
+// src/kernel/telemetry.ts
+var import_effect2 = require("effect");
+var Telemetry = class extends import_effect2.Context.Tag("EffectReact/Telemetry")() {
+};
+var TelemetryLive = import_effect2.Layer.effect(
+  Telemetry,
+  import_effect2.Effect.map(import_effect2.PubSub.unbounded(), (pubsub) => ({
+    emit: (event) => import_effect2.PubSub.publish(pubsub, event).pipe(import_effect2.Effect.asVoid),
+    stream: import_effect2.Stream.fromPubSub(pubsub)
+  }))
+);
+
+// src/actions/service.ts
+var toFailureDetail = (error) => {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+};
+var Actions = class extends import_effect3.Context.Tag("EffectReact/Actions")() {
+};
+var makeActionsLayer = (options) => import_effect3.Layer.effect(
+  Actions,
+  import_effect3.Effect.gen(function* () {
+    const boundary = yield* Boundary;
+    const telemetry = yield* Telemetry;
+    const actionMap = new Map(
+      options.actions.map((action) => [action.name, action])
+    );
+    const run = (definition, input) => import_effect3.Effect.gen(function* () {
+      yield* telemetry.emit({
+        _tag: "action",
+        phase: "start",
+        name: definition.name,
+        timestamp: Date.now()
+      });
+      const decodedInput = yield* boundary.decodeUnknown({
+        source: `action:${definition.name}:input`,
+        schema: definition.input,
+        value: input
+      });
+      const value = yield* definition.handler(decodedInput);
+      const decodedOutput = yield* boundary.decodeUnknown({
+        source: `action:${definition.name}:output`,
+        schema: definition.output,
+        value
+      });
+      yield* telemetry.emit({
+        _tag: "action",
+        phase: "success",
+        name: definition.name,
+        timestamp: Date.now()
+      });
+      return decodedOutput;
+    }).pipe(
+      import_effect3.Effect.tapError(
+        (error) => telemetry.emit({
+          _tag: "action",
+          phase: "failure",
+          name: definition.name,
+          timestamp: Date.now(),
+          detail: error
+        })
+      )
+    );
+    const dispatch = (name, input) => import_effect3.Effect.gen(function* () {
+      const definition = actionMap.get(name);
+      if (definition === void 0) {
+        return {
+          _tag: "defect",
+          message: `Unknown action: ${name}`
+        };
+      }
+      const decodedInput = yield* boundary.decodeUnknown({
+        source: `action:${name}:dispatch-input`,
+        schema: definition.input,
+        value: input
+      });
+      const handler = definition.handler;
+      const result = yield* import_effect3.Effect.exit(handler(decodedInput));
+      if (result._tag === "Success") {
+        const encoded = yield* boundary.encode({
+          source: `action:${name}:wire-success`,
+          schema: definition.output,
+          value: result.value
+        });
+        return {
+          _tag: "success",
+          value: encoded
+        };
+      }
+      const failure = import_effect3.Cause.failureOption(result.cause);
+      if (failure._tag === "Some") {
+        const value = failure.value;
+        if (value instanceof BoundaryDecodeError || value instanceof BoundaryProtocolError) {
+          return {
+            _tag: "defect",
+            message: toFailureDetail(value)
+          };
+        }
+        const encodedError = yield* boundary.encode({
+          source: `action:${name}:wire-failure`,
+          schema: definition.error,
+          value
+        }).pipe(
+          import_effect3.Effect.catchAll(() => import_effect3.Effect.succeed(value))
+        );
+        return {
+          _tag: "failure",
+          error: encodedError
+        };
+      }
+      return {
+        _tag: "defect",
+        message: import_effect3.Cause.pretty(result.cause)
+      };
+    }).pipe(
+      import_effect3.Effect.catchAll(
+        (error) => import_effect3.Effect.succeed({
+          _tag: "defect",
+          message: toFailureDetail(error)
+        })
+      )
+    );
+    return {
+      run,
+      dispatch
+    };
+  })
+);
+
+// src/actions/http.ts
+var import_effect4 = require("effect");
+var ActionRequestSchema = import_effect4.Schema.Struct({
+  name: import_effect4.Schema.String,
+  input: import_effect4.Schema.Unknown
+});
+var ActionWireResultSchema = import_effect4.Schema.Union(
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("success"), value: import_effect4.Schema.Unknown }),
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("failure"), error: import_effect4.Schema.Unknown }),
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("defect"), message: import_effect4.Schema.String })
+);
+var ActionTransportError = class extends Error {
+  constructor(messageText, causeValue) {
+    super(messageText);
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "ActionTransportError";
+  }
+  _tag = "ActionTransportError";
+};
+var jsonResponse = (status, body) => new Response(JSON.stringify(body), {
+  status,
+  headers: {
+    "content-type": "application/json"
+  }
+});
+var createActionHttpHandlerEffect = () => (request) => import_effect4.Effect.gen(function* () {
+  if (request.method.toUpperCase() !== "POST") {
+    return jsonResponse(405, { error: "Method Not Allowed" });
+  }
+  const rawBody = yield* import_effect4.Effect.tryPromise({
+    try: () => request.text(),
+    catch: (cause) => new ActionTransportError("Failed to read request body", cause)
+  });
+  const boundary = yield* Boundary;
+  const payload = yield* boundary.decodeTextJson({
+    source: "action:http:request",
+    schema: ActionRequestSchema,
+    text: rawBody
+  });
+  const actions = yield* Actions;
+  const result = yield* actions.dispatch(payload.name, payload.input);
+  return jsonResponse(200, result);
+}).pipe(
+  import_effect4.Effect.catchAll(
+    (error) => import_effect4.Effect.succeed(
+      jsonResponse(500, {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    )
+  )
+);
+var createActionHttpHandler = () => {
+  const handleEffect = createActionHttpHandlerEffect();
+  return (runtimeRun) => (request) => runtimeRun(handleEffect(request));
+};
+
+// src/kernel/app.ts
+var import_effect8 = require("effect");
+
+// src/data/types.ts
+var QueryRuntimeError = class extends Error {
+  constructor(messageText) {
+    super(messageText);
+    this.messageText = messageText;
+    this.name = "QueryRuntimeError";
+  }
+  _tag = "QueryRuntimeError";
+};
+
+// src/data/service.ts
+var import_effect5 = require("effect");
+var defaultRuntimeOptions = {
+  capacity: 2048,
+  timeToLive: "5 minutes"
+};
+var stableStringify = (value) => {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`).join(",")}}`;
+};
+var initialSnapshot = (key) => ({
+  key,
+  phase: "initial",
+  data: void 0,
+  error: void 0,
+  updatedAt: null
+});
+var Data = class extends import_effect5.Context.Tag("EffectReact/Data")() {
+};
+var makeDataLayer = (options = {}) => {
+  const merged = {
+    ...defaultRuntimeOptions,
+    ...options
+  };
+  return import_effect5.Layer.effect(
+    Data,
+    import_effect5.Effect.gen(function* () {
+      const boundary = yield* Boundary;
+      const telemetry = yield* Telemetry;
+      const lookups = /* @__PURE__ */ new Map();
+      const snapshots = yield* import_effect5.SubscriptionRef.make(
+        /* @__PURE__ */ new Map()
+      );
+      const cache = yield* import_effect5.Cache.make({
+        capacity: merged.capacity,
+        timeToLive: merged.timeToLive,
+        lookup: (key) => import_effect5.Effect.suspend(() => {
+          const lookup = lookups.get(key);
+          if (lookup === void 0) {
+            return import_effect5.Effect.fail(new QueryRuntimeError(`No query executor registered for ${key}`));
+          }
+          return lookup;
+        })
+      });
+      const setSnapshot = (key, update) => import_effect5.SubscriptionRef.update(snapshots, (current) => {
+        const next = new Map(current);
+        const previous = next.get(key) ?? initialSnapshot(key);
+        next.set(key, update(previous));
+        return next;
+      }).pipe(import_effect5.Effect.asVoid);
+      const buildKey = (definition, input) => {
+        const base = definition.key ? definition.key(input) : input;
+        return `${definition.name}:${stableStringify(base)}`;
+      };
+      const fetch2 = (definition, input, runOptions) => import_effect5.Effect.gen(function* () {
+        const decodedInput = yield* boundary.decodeUnknown({
+          source: `query:${definition.name}:input`,
+          schema: definition.input,
+          value: input
+        });
+        const key = buildKey(definition, decodedInput);
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "start",
+          key,
+          timestamp: Date.now()
+        });
+        yield* setSnapshot(key, (previous) => ({
+          ...previous,
+          phase: "loading",
+          error: void 0
+        }));
+        lookups.set(
+          key,
+          definition.run(decodedInput).pipe(
+            import_effect5.Effect.flatMap(
+              (output) => boundary.decodeUnknown({
+                source: `query:${definition.name}:output`,
+                schema: definition.output,
+                value: output
+              })
+            )
+          )
+        );
+        if (runOptions?.forceRefresh === true) {
+          yield* cache.refresh(key).pipe(import_effect5.Effect.ignore);
+        }
+        const value = yield* cache.get(key).pipe(
+          import_effect5.Effect.mapError(
+            (error) => error
+          )
+        );
+        yield* setSnapshot(key, () => ({
+          key,
+          phase: "success",
+          data: value,
+          error: void 0,
+          updatedAt: Date.now()
+        }));
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "success",
+          key,
+          timestamp: Date.now()
+        });
+        return value;
+      }).pipe(
+        import_effect5.Effect.tapError(
+          (error) => import_effect5.Effect.gen(function* () {
+            const decodedInput = yield* boundary.decodeUnknown({
+              source: `query:${definition.name}:input`,
+              schema: definition.input,
+              value: input
+            });
+            const key = buildKey(definition, decodedInput);
+            yield* setSnapshot(key, (previous) => ({
+              ...previous,
+              phase: "failure",
+              error,
+              updatedAt: previous.updatedAt
+            }));
+            yield* telemetry.emit({
+              _tag: "query",
+              phase: "failure",
+              key,
+              timestamp: Date.now(),
+              detail: error
+            });
+          })
+        )
+      );
+      const prefetch = (definition, input) => fetch2(definition, input).pipe(import_effect5.Effect.asVoid);
+      const invalidate = (definition, input) => import_effect5.Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        yield* cache.invalidate(key);
+        yield* import_effect5.SubscriptionRef.update(snapshots, (current) => {
+          const next = new Map(current);
+          next.delete(key);
+          return next;
+        }).pipe(import_effect5.Effect.asVoid);
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "invalidate",
+          key,
+          timestamp: Date.now()
+        });
+      });
+      const getSnapshot = (definition, input) => import_effect5.Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        const current = yield* import_effect5.SubscriptionRef.get(snapshots);
+        const snapshot = current.get(key);
+        if (snapshot === void 0) {
+          return initialSnapshot(key);
+        }
+        return snapshot;
+      });
+      return {
+        fetch: fetch2,
+        prefetch,
+        invalidate,
+        getSnapshot,
+        getAllSnapshots: import_effect5.SubscriptionRef.get(snapshots),
+        hydrateSnapshots: (nextSnapshots) => import_effect5.SubscriptionRef.set(snapshots, new Map(nextSnapshots)),
+        snapshots: snapshots.changes
+      };
+    })
+  );
+};
+
+// src/navigation/types.ts
+var NavigationRuntimeError = class extends Error {
+  constructor(messageText) {
+    super(messageText);
+    this.messageText = messageText;
+    this.name = "NavigationRuntimeError";
+  }
+  _tag = "NavigationRuntimeError";
+};
+var NavigationCancelledError = class extends Error {
+  constructor(pathname) {
+    super(`Navigation cancelled for ${pathname}`);
+    this.pathname = pathname;
+    this.name = "NavigationCancelledError";
+  }
+  _tag = "NavigationCancelledError";
+};
+
+// src/navigation/matcher.ts
+var normalizePathname = (pathname) => {
+  if (pathname.length === 0) {
+    return "/";
+  }
+  const withSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withSlash.length > 1 && withSlash.endsWith("/")) {
+    return withSlash.slice(0, -1);
+  }
+  return withSlash;
+};
+var scoreRoute = (path) => {
+  if (path === "/") {
+    return 10;
+  }
+  return path.split("/").filter((segment) => segment.length > 0).reduce((score, segment) => {
+    if (segment === "*") {
+      return score;
+    }
+    if (segment.startsWith(":")) {
+      return score + 2;
+    }
+    return score + 5;
+  }, 0);
+};
+var splitSegments = (path) => normalizePathname(path).split("/").filter((segment) => segment.length > 0);
+var matchRoutePath = (routePath, pathname) => {
+  const routeSegments = splitSegments(routePath);
+  const pathSegments = splitSegments(pathname);
+  const params = {};
+  let i = 0;
+  let j = 0;
+  while (i < routeSegments.length && j < pathSegments.length) {
+    const routeSegment = routeSegments[i];
+    const pathSegment = pathSegments[j];
+    if (routeSegment === "*") {
+      return params;
+    }
+    if (routeSegment.startsWith(":")) {
+      params[routeSegment.slice(1)] = decodeURIComponent(pathSegment);
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (routeSegment !== pathSegment) {
+      return null;
+    }
+    i += 1;
+    j += 1;
+  }
+  if (i < routeSegments.length && routeSegments[i] === "*") {
+    return params;
+  }
+  if (i !== routeSegments.length || j !== pathSegments.length) {
+    return null;
+  }
+  return params;
+};
+var matchRoute = ({ routes, pathname, search }) => {
+  const normalized = normalizePathname(pathname);
+  const sorted = [...routes].sort((a, b) => scoreRoute(b.path) - scoreRoute(a.path));
+  for (const route of sorted) {
+    const params = matchRoutePath(route.path, normalized);
+    if (params !== null) {
+      return {
+        route,
+        pathname: normalized,
+        params,
+        search
+      };
+    }
+  }
+  return null;
+};
+var buildHref = (pathname, searchText) => searchText.length > 0 ? `${normalizePathname(pathname)}${searchText}` : normalizePathname(pathname);
+var normalizeSearchText = (searchText) => {
+  if (searchText.length === 0 || searchText === "?") {
+    return "";
+  }
+  return searchText.startsWith("?") ? searchText : `?${searchText}`;
+};
+var parseHref = (href) => {
+  const [pathPart, ...searchParts] = href.split("?");
+  return {
+    pathname: normalizePathname(pathPart ?? "/"),
+    searchText: normalizeSearchText(searchParts.length === 0 ? "" : searchParts.join("?"))
+  };
+};
+
+// src/navigation/service.ts
+var import_effect6 = require("effect");
+var describeUnknown = (value) => {
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}`;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var initialSnapshot2 = {
+  pathname: "/",
+  searchText: "",
+  href: "/",
+  status: "idle",
+  match: null,
+  loaders: {},
+  error: void 0
+};
+var toLoadersByName = (loaders) => new Map(loaders.map((loader) => [loader.name, loader]));
+var planLoaderBatches = (loaders) => {
+  const byName = toLoadersByName(loaders);
+  const depthByName = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const resolveDepth = (name) => {
+    const cached = depthByName.get(name);
+    if (cached !== void 0) {
+      return import_effect6.Effect.succeed(cached);
+    }
+    if (visiting.has(name)) {
+      return import_effect6.Effect.fail(new NavigationRuntimeError(`Cyclic loader dependency detected at ${name}`));
+    }
+    const loader = byName.get(name);
+    if (loader === void 0) {
+      return import_effect6.Effect.fail(new NavigationRuntimeError(`Loader dependency '${name}' is not registered`));
+    }
+    visiting.add(name);
+    const dependencies = loader.dependsOn ?? [];
+    return import_effect6.Effect.forEach(dependencies, resolveDepth).pipe(
+      import_effect6.Effect.map((depths) => {
+        const depth = depths.length === 0 ? 0 : Math.max(...depths) + 1;
+        depthByName.set(name, depth);
+        visiting.delete(name);
+        return depth;
+      }),
+      import_effect6.Effect.catchAll((error) => {
+        visiting.delete(name);
+        return import_effect6.Effect.fail(error);
+      })
+    );
+  };
+  return import_effect6.Effect.gen(function* () {
+    const entries = yield* import_effect6.Effect.forEach(
+      loaders,
+      (loader) => import_effect6.Effect.map(resolveDepth(loader.name), (depth) => [depth, loader])
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [depth, loader] of entries) {
+      const existing = grouped.get(depth);
+      if (existing === void 0) {
+        grouped.set(depth, [loader]);
+      } else {
+        existing.push(loader);
+      }
+    }
+    const depths = Array.from(grouped.keys()).sort((a, b) => a - b);
+    return depths.map((depth) => grouped.get(depth) ?? []);
+  });
+};
+var Navigation = class extends import_effect6.Context.Tag("EffectReact/Navigation")() {
+};
+var makeNavigationLayer = (options) => {
+  const loaders = options.loaders ?? [];
+  const initial = parseHref(options.initialHref ?? "/");
+  return import_effect6.Layer.effect(
+    Navigation,
+    import_effect6.Effect.gen(function* () {
+      const boundary = yield* Boundary;
+      const telemetry = yield* Telemetry;
+      const snapshotsRef = yield* import_effect6.SubscriptionRef.make({
+        ...initialSnapshot2,
+        pathname: initial.pathname,
+        searchText: initial.searchText,
+        href: buildHref(initial.pathname, initial.searchText)
+      });
+      const activeFiberRef = yield* import_effect6.Ref.make(import_effect6.Option.none());
+      const runLoaders = (snapshot) => import_effect6.Effect.gen(function* () {
+        if (snapshot.match === null) {
+          return {};
+        }
+        const routeLoaders = loaders.filter((loader) => loader.routeId === snapshot.match.route.id);
+        if (routeLoaders.length === 0) {
+          return {};
+        }
+        const batches = yield* planLoaderBatches(routeLoaders);
+        const results = {};
+        const states = {};
+        for (const loader of routeLoaders) {
+          states[loader.name] = { _tag: "pending" };
+        }
+        yield* import_effect6.SubscriptionRef.update(snapshotsRef, (current) => ({
+          ...current,
+          loaders: {
+            ...current.loaders,
+            ...states
+          }
+        }));
+        for (const batch of batches) {
+          const exits = yield* import_effect6.Effect.all(
+            batch.map((loader) => {
+              const base = loader.run({
+                route: snapshot.match.route,
+                pathname: snapshot.pathname,
+                searchText: snapshot.searchText,
+                params: snapshot.match.params,
+                search: snapshot.match.search,
+                dependencyResults: results
+              });
+              const withRetry = loader.retry ? import_effect6.Effect.retry(base, loader.retry) : base;
+              return import_effect6.Effect.exit(withRetry).pipe(import_effect6.Effect.map((exit) => [loader, exit]));
+            }),
+            {
+              concurrency: "unbounded"
+            }
+          );
+          for (const [loader, exit] of exits) {
+            if (exit._tag === "Success") {
+              results[loader.name] = exit.value;
+              states[loader.name] = {
+                _tag: "success",
+                value: exit.value
+              };
+              continue;
+            }
+            const failure = import_effect6.Cause.failureOption(exit.cause);
+            states[loader.name] = {
+              _tag: "failure",
+              error: failure._tag === "Some" ? failure.value : import_effect6.Cause.pretty(exit.cause)
+            };
+            yield* import_effect6.SubscriptionRef.update(snapshotsRef, (current) => ({
+              ...current,
+              status: "failure",
+              loaders: {
+                ...current.loaders,
+                ...states
+              },
+              error: states[loader.name]
+            }));
+            return yield* import_effect6.Effect.fail(
+              new NavigationRuntimeError(`Loader '${loader.name}' failed for route '${snapshot.match.route.id}'`)
+            );
+          }
+          yield* import_effect6.SubscriptionRef.update(snapshotsRef, (current) => ({
+            ...current,
+            loaders: {
+              ...current.loaders,
+              ...states
+            }
+          }));
+        }
+        return states;
+      });
+      const performNavigation = (href) => import_effect6.Effect.gen(function* () {
+        const { pathname, searchText } = parseHref(href);
+        const searchParams = new URLSearchParams(searchText);
+        const candidate = options.routes.find((route) => matchRoute({
+          routes: [route],
+          pathname,
+          search: {}
+        }) !== null);
+        const decodedSearch = candidate?.search === void 0 ? import_effect6.Effect.succeed({}) : boundary.decodeUnknown({
+          source: `route:${candidate.id}:search`,
+          schema: candidate.search,
+          value: Object.fromEntries(searchParams.entries())
+        });
+        const search = yield* decodedSearch;
+        const matched = matchRoute({
+          routes: options.routes,
+          pathname,
+          search
+        });
+        if (matched === null) {
+          return yield* import_effect6.Effect.fail(
+            new NavigationRuntimeError(`No route matched pathname '${pathname}'`)
+          );
+        }
+        yield* telemetry.emit({
+          _tag: "navigation",
+          phase: "start",
+          pathname,
+          routeId: matched.route.id,
+          timestamp: Date.now()
+        });
+        const loadingSnapshot = {
+          pathname,
+          searchText: normalizeSearchText(searchText),
+          href: buildHref(pathname, normalizeSearchText(searchText)),
+          status: "loading",
+          match: matched,
+          loaders: {},
+          error: void 0
+        };
+        yield* import_effect6.SubscriptionRef.set(snapshotsRef, loadingSnapshot);
+        const loaderStates = yield* runLoaders(loadingSnapshot);
+        const completed = {
+          ...loadingSnapshot,
+          status: "success",
+          loaders: loaderStates,
+          error: void 0
+        };
+        yield* import_effect6.SubscriptionRef.set(snapshotsRef, completed);
+        yield* telemetry.emit({
+          _tag: "navigation",
+          phase: "success",
+          pathname,
+          routeId: matched.route.id,
+          timestamp: Date.now()
+        });
+        return completed;
+      });
+      const navigate = (href) => import_effect6.Effect.gen(function* () {
+        const previous = yield* import_effect6.Ref.getAndSet(activeFiberRef, import_effect6.Option.none());
+        if (import_effect6.Option.isSome(previous)) {
+          yield* import_effect6.Fiber.interrupt(previous.value);
+          yield* telemetry.emit({
+            _tag: "navigation",
+            phase: "cancel",
+            pathname: href,
+            timestamp: Date.now()
+          });
+        }
+        const fiber = yield* import_effect6.Effect.fork(performNavigation(href));
+        yield* import_effect6.Ref.set(activeFiberRef, import_effect6.Option.some(fiber));
+        const exit = yield* import_effect6.Effect.exit(import_effect6.Fiber.join(fiber));
+        const current = yield* import_effect6.Ref.get(activeFiberRef);
+        if (import_effect6.Option.isSome(current) && current.value === fiber) {
+          yield* import_effect6.Ref.set(activeFiberRef, import_effect6.Option.none());
+        }
+        if (exit._tag === "Success") {
+          return exit.value;
+        }
+        if (import_effect6.Cause.isInterruptedOnly(exit.cause)) {
+          return yield* import_effect6.Effect.fail(new NavigationCancelledError(href));
+        }
+        const failure = import_effect6.Cause.failureOption(exit.cause);
+        if (failure._tag === "Some") {
+          return yield* import_effect6.Effect.fail(
+            failure.value instanceof NavigationRuntimeError ? failure.value : new NavigationRuntimeError(describeUnknown(failure.value))
+          );
+        }
+        return yield* import_effect6.Effect.fail(new NavigationRuntimeError(import_effect6.Cause.pretty(exit.cause)));
+      }).pipe(
+        import_effect6.Effect.tapError(
+          (error) => telemetry.emit({
+            _tag: "navigation",
+            phase: "failure",
+            pathname: href,
+            timestamp: Date.now(),
+            detail: error
+          })
+        )
+      );
+      const revalidate = () => import_effect6.Effect.gen(function* () {
+        const snapshot = yield* import_effect6.SubscriptionRef.get(snapshotsRef);
+        return yield* navigate(snapshot.href);
+      });
+      return {
+        navigate,
+        revalidate,
+        getSnapshot: import_effect6.SubscriptionRef.get(snapshotsRef),
+        hydrateSnapshot: (snapshot) => import_effect6.SubscriptionRef.set(snapshotsRef, snapshot),
+        snapshots: snapshotsRef.changes
+      };
+    })
+  );
+};
+
+// src/kernel/runtime.ts
+var import_effect7 = require("effect");
+var createManagedRuntime = (layer) => import_effect7.ManagedRuntime.make(layer);
+
+// src/kernel/app.ts
+var createAppLayer = (options) => {
+  const boundaryLayer = BoundaryLive;
+  const telemetryLayer = TelemetryLive;
+  const dataLayer = makeDataLayer(options.data).pipe(
+    import_effect8.Layer.provide([boundaryLayer, telemetryLayer])
+  );
+  const actionsLayer = makeActionsLayer({
+    actions: options.actions ?? []
+  }).pipe(import_effect8.Layer.provide([boundaryLayer, telemetryLayer]));
+  const navigationLayer = makeNavigationLayer({
+    routes: options.routes,
+    ...options.loaders !== void 0 ? { loaders: options.loaders } : {},
+    ...options.initialHref !== void 0 ? { initialHref: options.initialHref } : {}
+  }).pipe(import_effect8.Layer.provide([boundaryLayer, telemetryLayer]));
+  return import_effect8.Layer.mergeAll(boundaryLayer, telemetryLayer, dataLayer, actionsLayer, navigationLayer);
+};
+var createAppRuntime = (options) => createManagedRuntime(createAppLayer(options));
+
+// src/framework/manifest.ts
+var routesFromManifest = (manifest) => manifest.pages.map((page) => page.route);
+var loadersFromManifest = (manifest) => {
+  const pageLoaders = manifest.pages.map((page) => page.loader).filter((loader) => loader !== void 0);
+  const layoutLoaders = (manifest.layouts ?? []).map((layout) => layout.loader).filter((loader) => loader !== void 0);
+  return [...pageLoaders, ...layoutLoaders];
+};
+
+// src/config/index.ts
+var defaultConfig = {
+  appDir: "app",
+  adapters: ["node", "bun"],
+  ssr: {
+    streaming: true
+  },
+  cache: {
+    defaultPolicy: "no-store",
+    routeSegmentDefaults: "explicit"
+  },
+  strict: {
+    boundarySchemas: true,
+    typedErrors: true
+  }
+};
+var resolveConfig = (config = {}) => ({
+  appDir: config.appDir ?? defaultConfig.appDir,
+  adapters: config.adapters ?? defaultConfig.adapters,
+  ssr: {
+    streaming: config.ssr?.streaming ?? defaultConfig.ssr.streaming
+  },
+  cache: {
+    defaultPolicy: config.cache?.defaultPolicy ?? defaultConfig.cache.defaultPolicy,
+    routeSegmentDefaults: config.cache?.routeSegmentDefaults ?? defaultConfig.cache.routeSegmentDefaults
+  },
+  strict: {
+    boundarySchemas: config.strict?.boundarySchemas ?? defaultConfig.strict.boundarySchemas,
+    typedErrors: config.strict?.typedErrors ?? defaultConfig.strict.typedErrors
+  }
+});
+
+// src/framework/app.ts
+var createPageMatcher = (pages) => {
+  const routes = pages.map((page) => page.route);
+  return (href) => {
+    const parsed = parseHref(href);
+    const matched = matchRoute({
+      routes,
+      pathname: parsed.pathname,
+      search: {}
+    });
+    if (matched === null) {
+      return void 0;
+    }
+    return pages.find((page) => page.route.id === matched.route.id);
+  };
+};
+var createApp = (options) => {
+  const manifest = options.manifest;
+  const routes = routesFromManifest(manifest);
+  const loaders = loadersFromManifest(manifest);
+  const actions = manifest.actions ?? [];
+  const runtime = createAppRuntime({
+    routes,
+    actions,
+    loaders,
+    ...options.initialHref !== void 0 ? { initialHref: options.initialHref } : {}
+  });
+  const actionHandlerFactory = createActionHttpHandler();
+  const handleActionRequest = actionHandlerFactory((effect) => runtime.runPromise(effect));
+  return {
+    manifest,
+    config: resolveConfig(options.config),
+    runtime,
+    actions,
+    matchPage: createPageMatcher(manifest.pages),
+    handleActionRequest,
+    dispose: () => runtime.dispose()
+  };
+};
+
+// src/testing/index.ts
+var createTestApp = (options) => createApp(options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTestApp
+});
+//# sourceMappingURL=index.cjs.map