effective-rsc 0.1.0

package/dist/application/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/component.js","sources":["../../src/application/component.ts"],"sourcesContent":["import { Effect } from 'effect';\nimport type { ReactNode } from 'react';\n\nimport { attachERSCMember, type ERSCIdentity, type ERSCMember } from './ersc-identity';\nimport type { AnyMiddleware } from './middleware';\n\nexport interface EffectComponent<Props, ApplicationServices> extends ERSCMember<\n  ApplicationServices,\n  'Component'\n> {\n  (props: Props): Promise<Awaited<ReactNode>>;\n}\n\ntype ComponentOptions<Props, Error, AvailableServices> = {\n  readonly render: (props: Props) => Effect.Effect<Awaited<ReactNode>, Error, AvailableServices>;\n};\n\nexport type ComponentFactory<ApplicationServices, AvailableServices> = {\n  readonly make: <Props, Error>(\n    options: ComponentOptions<Props, Error, AvailableServices>,\n  ) => EffectComponent<Props, ApplicationServices>;\n};\n\nexport const makeComponentFactory = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n): ComponentFactory<ApplicationServices, AvailableServices> => {\n  const make = <Props, Error>({\n    render,\n  }: ComponentOptions<Props, Error, AvailableServices>): EffectComponent<\n    Props,\n    ApplicationServices\n  > => {\n    const EffectComponent = (props: Props): Promise<Awaited<ReactNode>> =>\n      identity.renderRuntime.run(\n        'Component',\n        Effect.suspend(() => render(props)),\n        middleware,\n      );\n\n    return attachERSCMember(EffectComponent, identity, 'Component');\n  };\n\n  return { make };\n};\n"],"names":["Effect","attachERSCMember","makeComponentFactory","identity","middleware","make","render","EffectComponent","props"],"mappings":";;;;;AAAgC;AAGuD;AAoBhF,MAAME,oBAAoBA,GAAG,CAClCC,UACAC;IAEA,MAAMC,OAAO,CAAe,EAC1BC,MAAM,EAC4C;QAIlD,MAAMC,kBAAkB,CAACC,QACvBL,SAAS,aAAa,CAAC,GAAG,CACxB,aACAH,cAAc,CAAC,IAAMM,OAAOE,SAC5BJ;QAGJ,OAAOH,gBAAgBA,CAACM,iBAAiBJ,UAAU;IACrD;IAEA,OAAO;QAAEE;IAAK;AAChB,EAAE"}

package/dist/application/definition.d.ts

@@ -0,0 +1,31 @@
+import { Layer, type Types } from 'effect';
+import type { HttpRouter } from 'effect/unstable/http';
+import { type ERSCIdentity, type ERSCStatefulMember } from './ersc-identity.js';
+import { type CompiledRouteGraph } from './route-graph.js';
+import type { AbsolutePath, ReservedRoutePath } from './route-path.js';
+import { type AnyRoutes, type RoutesHasLayout, type RoutesPaths } from './routes.js';
+declare const ApplicationContractTypeId: unique symbol;
+export interface ApplicationDefinition<Services, out ApplicationError = never> extends ERSCStatefulMember<Services, 'Application', ApplicationImplementationState<Services, ApplicationError>> {
+    readonly [ApplicationContractTypeId]: {
+        readonly error: Types.Covariant<ApplicationError>;
+    };
+}
+export type ApplicationImplementationState<Services, ApplicationError> = {
+    readonly layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;
+    readonly routes: CompiledRouteGraph<Services>;
+};
+export declare const getApplicationState: <Services, ApplicationError>(application: ApplicationDefinition<Services, ApplicationError>) => ApplicationImplementationState<Services, ApplicationError>;
+export type ApplicationServices<Application> = Application extends ApplicationDefinition<infer Services, infer _ApplicationError> ? Services : never;
+type ValidRootRoutes<Services, Definition extends AnyRoutes<Services>> = RoutesHasLayout<Definition> extends true ? [RoutesPaths<Definition>] extends [never] ? never : [ReservedRoutes<RoutesPaths<Definition>>] extends [never] ? unknown : never : never;
+type ReservedRoutes<Paths> = Paths extends AbsolutePath ? ReservedRoutePath<Paths> : never;
+type ApplicationLayerOptions<Services, ApplicationError> = [Services] extends [never] ? {
+    readonly layer?: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;
+} : {
+    readonly layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;
+};
+export type ERSCApplicationOptions<Services, Definition extends AnyRoutes<Services>, ApplicationError> = {
+    readonly routes: Definition & ValidRootRoutes<Services, Definition>;
+} & ApplicationLayerOptions<Services, ApplicationError>;
+export type ERSCMake<Services> = <Definition extends AnyRoutes<Services>, ApplicationError = never>(options: ERSCApplicationOptions<Services, Definition, ApplicationError>) => ApplicationDefinition<Services, ApplicationError>;
+export declare const makeApplication: <Services, Definition extends AnyRoutes<Services>, ApplicationError = never>(identity: ERSCIdentity<Services>, { layer, routes }: ERSCApplicationOptions<Services, Definition, ApplicationError>) => ApplicationDefinition<Services, ApplicationError>;
+export {};

package/dist/application/definition.js

@@ -0,0 +1,57 @@
+import { Layer } from "effect";
+import { ERSCIdentityTypeId, ERSCMemberKindTypeId, ERSCStateTypeId, getERSCIdentity, isERSCMember } from "./ersc-identity.js";
+import { compileRouteGraph } from "./route-graph.js";
+
+
+
+
+
+
+
+class ApplicationDefinitionImpl {
+    [ERSCIdentityTypeId];
+    [ERSCMemberKindTypeId] = 'Application';
+    get [ERSCStateTypeId]() {
+        return this;
+    }
+    layer;
+    routes;
+    constructor(identity, routes, layer){
+        this[ERSCIdentityTypeId] = identity;
+        this.layer = layer;
+        this.routes = routes;
+        Object.defineProperties(this, {
+            [ERSCIdentityTypeId]: {
+                configurable: false,
+                writable: false
+            },
+            layer: {
+                configurable: false,
+                writable: false
+            },
+            routes: {
+                configurable: false,
+                writable: false
+            }
+        });
+    }
+}
+const getApplicationState = (application)=>{
+    if (!isERSCMember(application, 'Application')) {
+        throw new TypeError('Application must be created with ERSC.make.');
+    }
+    return application[ERSCStateTypeId];
+};
+function resolveApplicationLayer(layer) {
+    return layer ?? Layer.empty;
+}
+const makeApplication = (identity, { layer, routes })=>{
+    if (getERSCIdentity(routes) !== identity) {
+        throw new TypeError('Root Routes were created by a different ERSC module.');
+    }
+    return new ApplicationDefinitionImpl(identity, compileRouteGraph(routes), resolveApplicationLayer(layer));
+};
+
+export { getApplicationState, makeApplication };
+
+//# sourceMappingURL=definition.js.map

package/dist/application/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/definition.js","sources":["../../src/application/definition.tsx"],"sourcesContent":["import { Layer, type Types } from 'effect';\nimport type { HttpRouter } from 'effect/unstable/http';\n\nimport {\n  type ERSCIdentity,\n  ERSCIdentityTypeId,\n  ERSCMemberKindTypeId,\n  type ERSCStatefulMember,\n  ERSCStateTypeId,\n  getERSCIdentity,\n  isERSCMember,\n} from './ersc-identity';\nimport { type CompiledRouteGraph, compileRouteGraph } from './route-graph';\nimport type { AbsolutePath, ReservedRoutePath } from './route-path';\nimport { type AnyRoutes, type RoutesHasLayout, type RoutesPaths } from './routes';\n\ndeclare const ApplicationContractTypeId: unique symbol;\n\nexport interface ApplicationDefinition<\n  Services,\n  out ApplicationError = never,\n> extends ERSCStatefulMember<\n  Services,\n  'Application',\n  ApplicationImplementationState<Services, ApplicationError>\n> {\n  readonly [ApplicationContractTypeId]: {\n    readonly error: Types.Covariant<ApplicationError>;\n  };\n}\n\nexport type ApplicationImplementationState<Services, ApplicationError> = {\n  readonly layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;\n  readonly routes: CompiledRouteGraph<Services>;\n};\n\nclass ApplicationDefinitionImpl<Services, ApplicationError> implements ApplicationDefinition<\n  Services,\n  ApplicationError\n> {\n  declare readonly [ApplicationContractTypeId]: {\n    readonly error: Types.Covariant<ApplicationError>;\n  };\n  readonly [ERSCIdentityTypeId]: ERSCIdentity<Services>;\n  readonly [ERSCMemberKindTypeId] = 'Application' as const;\n  get [ERSCStateTypeId](): ApplicationImplementationState<Services, ApplicationError> {\n    return this;\n  }\n  readonly layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;\n  readonly routes: CompiledRouteGraph<Services>;\n\n  constructor(\n    identity: ERSCIdentity<Services>,\n    routes: CompiledRouteGraph<Services>,\n    layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>,\n  ) {\n    this[ERSCIdentityTypeId] = identity;\n    this.layer = layer;\n    this.routes = routes;\n    Object.defineProperties(this, {\n      [ERSCIdentityTypeId]: { configurable: false, writable: false },\n      layer: { configurable: false, writable: false },\n      routes: { configurable: false, writable: false },\n    });\n  }\n}\n\nexport const getApplicationState = <Services, ApplicationError>(\n  application: ApplicationDefinition<Services, ApplicationError>,\n): ApplicationImplementationState<Services, ApplicationError> => {\n  if (!isERSCMember(application, 'Application')) {\n    throw new TypeError('Application must be created with ERSC.make.');\n  }\n  return application[ERSCStateTypeId];\n};\n\nexport type ApplicationServices<Application> =\n  Application extends ApplicationDefinition<infer Services, infer _ApplicationError>\n    ? Services\n    : never;\n\ntype ValidRootRoutes<Services, Definition extends AnyRoutes<Services>> =\n  RoutesHasLayout<Definition> extends true\n    ? [RoutesPaths<Definition>] extends [never]\n      ? never\n      : [ReservedRoutes<RoutesPaths<Definition>>] extends [never]\n        ? unknown\n        : never\n    : never;\n\ntype ReservedRoutes<Paths> = Paths extends AbsolutePath ? ReservedRoutePath<Paths> : never;\n\ntype ApplicationLayerOptions<Services, ApplicationError> = [Services] extends [never]\n  ? {\n      readonly layer?: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;\n    }\n  : {\n      readonly layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;\n    };\n\nexport type ERSCApplicationOptions<\n  Services,\n  Definition extends AnyRoutes<Services>,\n  ApplicationError,\n> = {\n  readonly routes: Definition & ValidRootRoutes<Services, Definition>;\n} & ApplicationLayerOptions<Services, ApplicationError>;\n\nexport type ERSCMake<Services> = <Definition extends AnyRoutes<Services>, ApplicationError = never>(\n  options: ERSCApplicationOptions<Services, Definition, ApplicationError>,\n) => ApplicationDefinition<Services, ApplicationError>;\n\nfunction resolveApplicationLayer<Services, ApplicationError>(\n  layer: Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter> | undefined,\n): Layer.Layer<Services, ApplicationError, HttpRouter.HttpRouter>;\nfunction resolveApplicationLayer(layer: Layer.Any | undefined): Layer.Any {\n  return layer ?? Layer.empty;\n}\n\nexport const makeApplication = <\n  Services,\n  Definition extends AnyRoutes<Services>,\n  ApplicationError = never,\n>(\n  identity: ERSCIdentity<Services>,\n  { layer, routes }: ERSCApplicationOptions<Services, Definition, ApplicationError>,\n): ApplicationDefinition<Services, ApplicationError> => {\n  if (getERSCIdentity(routes) !== identity) {\n    throw new TypeError('Root Routes were created by a different ERSC module.');\n  }\n\n  return new ApplicationDefinitionImpl(\n    identity,\n    compileRouteGraph(routes),\n    resolveApplicationLayer<Services, ApplicationError>(layer),\n  );\n};\n"],"names":["Layer","ERSCIdentityTypeId","ERSCMemberKindTypeId","ERSCStateTypeId","getERSCIdentity","isERSCMember","compileRouteGraph","ApplicationDefinitionImpl","identity","routes","layer","Object","getApplicationState","application","TypeError","resolveApplicationLayer","makeApplication"],"mappings":";;;;;;;AAA2C;AAWlB;AACkD;AAwB3E,MAAMO,yBAAyBA;IAOpB,CAACN,kBAAkBA,CAAC,CAAyB;IAC7C,CAACC,oBAAoBA,CAAC,GAAG,cAAuB;IACzD,IAAI,CAACC,eAAeA,CAAC,GAA+D;QAClF,OAAO,IAAI;IACb;IACS,MAAsE;IACtE,OAAqC;IAE9C,YACEK,QAAgC,EAChCC,MAAoC,EACpCC,KAAqE,CACrE;QACA,IAAI,CAACT,kBAAkBA,CAAC,GAAGO;QAC3B,IAAI,CAAC,KAAK,GAAGE;QACb,IAAI,CAAC,MAAM,GAAGD;QACdE,OAAO,gBAAgB,CAAC,IAAI,EAAE;YAC5B,CAACV,kBAAkBA,CAAC,EAAE;gBAAE,cAAc;gBAAO,UAAU;YAAM;YAC7D,OAAO;gBAAE,cAAc;gBAAO,UAAU;YAAM;YAC9C,QAAQ;gBAAE,cAAc;gBAAO,UAAU;YAAM;QACjD;IACF;AACF;AAEO,MAAMW,mBAAmBA,GAAG,CACjCC;IAEA,IAAI,CAACR,YAAYA,CAACQ,aAAa,gBAAgB;QAC7C,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOD,WAAW,CAACV,eAAeA,CAAC;AACrC,EAAE;AAyCF,SAASY,uBAAuBA,CAACL,KAA4B;IAC3D,OAAOA,SAASV,WAAW;AAC7B;AAEO,MAAMgB,eAAeA,GAAG,CAK7BR,UACA,EAAEE,KAAK,EAAED,MAAM,EAAkE;IAEjF,IAAIL,eAAeA,CAACK,YAAYD,UAAU;QACxC,MAAM,IAAIM,UAAU;IACtB;IAEA,OAAO,IAAIP,yBAAyBA,CAClCC,UACAF,iBAAiBA,CAACG,SAClBM,uBAAuBA,CAA6BL;AAExD,EAAE"}

package/dist/application/ersc-identity.d.ts

@@ -0,0 +1,25 @@
+import { type Types } from 'effect';
+import { type RenderRuntimeContext } from './render-runtime.js';
+declare const ERSCServicesTypeId: unique symbol;
+export declare const ERSCIdentityTypeId: unique symbol;
+export declare const ERSCMemberKindTypeId: unique symbol;
+export declare const ERSCStateTypeId: unique symbol;
+export type ERSCMemberKind = 'Application' | 'Component' | 'ERSC' | 'Layout' | 'Loading' | 'Middleware' | 'Page' | 'Routes' | 'ServerFn';
+export type ERSCIdentity<Services> = {
+    readonly [ERSCServicesTypeId]?: Types.Invariant<Services>;
+    readonly renderRuntime: RenderRuntimeContext;
+};
+type ERSCMemberKindMarker<Kind extends ERSCMemberKind> = {
+    readonly [ERSCMemberKindTypeId]: Kind;
+};
+export type ERSCMember<Services, Kind extends ERSCMemberKind = ERSCMemberKind> = ERSCMemberKindMarker<Kind> & {
+    readonly [ERSCIdentityTypeId]: ERSCIdentity<Services>;
+};
+export type ERSCStatefulMember<Services, Kind extends ERSCMemberKind, State> = ERSCMember<Services, Kind> & {
+    readonly [ERSCStateTypeId]: State;
+};
+export declare const makeERSCIdentity: <Services>() => ERSCIdentity<Services>;
+export declare const attachERSCMember: <Member extends object, Services, const Kind extends ERSCMemberKind>(member: Member, identity: ERSCIdentity<Services>, kind: Kind) => Member & ERSCMember<Services, Kind>;
+export declare const isERSCMember: <const Kind extends ERSCMemberKind>(value: unknown, kind: Kind) => value is ERSCMemberKindMarker<Kind>;
+export declare const getERSCIdentity: <Services>(member: ERSCMember<Services>) => ERSCIdentity<Services>;
+export {};

package/dist/application/ersc-identity.js

@@ -0,0 +1,23 @@
+import { Predicate } from "effect";
+import { makeRenderRuntimeContext } from "./render-runtime.js";
+
+
+
+
+
+const ERSCIdentityTypeId = Symbol.for('ersc/ERSCIdentity');
+const ERSCMemberKindTypeId = Symbol.for('ersc/ERSCMemberKind');
+const ERSCStateTypeId = Symbol.for('ersc/ERSCState');
+const makeERSCIdentity = ()=>({
+        renderRuntime: makeRenderRuntimeContext()
+    });
+const attachERSCMember = (member, identity, kind)=>Object.assign(member, {
+        [ERSCIdentityTypeId]: identity,
+        [ERSCMemberKindTypeId]: kind
+    });
+const isERSCMember = (value, kind)=>Predicate.hasProperty(value, ERSCMemberKindTypeId) && value[ERSCMemberKindTypeId] === kind;
+const getERSCIdentity = (member)=>member[ERSCIdentityTypeId];
+
+export { ERSCIdentityTypeId, ERSCMemberKindTypeId, ERSCStateTypeId, attachERSCMember, getERSCIdentity, isERSCMember, makeERSCIdentity };
+
+//# sourceMappingURL=ersc-identity.js.map

package/dist/application/ersc-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/ersc-identity.js","sources":["../../src/application/ersc-identity.ts"],"sourcesContent":["import { Predicate, type Types } from 'effect';\n\nimport { makeRenderRuntimeContext, type RenderRuntimeContext } from './render-runtime';\n\ndeclare const ERSCServicesTypeId: unique symbol;\n\nexport const ERSCIdentityTypeId: unique symbol = Symbol.for('ersc/ERSCIdentity');\nexport const ERSCMemberKindTypeId: unique symbol = Symbol.for('ersc/ERSCMemberKind');\nexport const ERSCStateTypeId: unique symbol = Symbol.for('ersc/ERSCState');\n\nexport type ERSCMemberKind =\n  | 'Application'\n  | 'Component'\n  | 'ERSC'\n  | 'Layout'\n  | 'Loading'\n  | 'Middleware'\n  | 'Page'\n  | 'Routes'\n  | 'ServerFn';\n\nexport type ERSCIdentity<Services> = {\n  readonly [ERSCServicesTypeId]?: Types.Invariant<Services>;\n  readonly renderRuntime: RenderRuntimeContext;\n};\n\ntype ERSCMemberKindMarker<Kind extends ERSCMemberKind> = {\n  readonly [ERSCMemberKindTypeId]: Kind;\n};\n\nexport type ERSCMember<\n  Services,\n  Kind extends ERSCMemberKind = ERSCMemberKind,\n> = ERSCMemberKindMarker<Kind> & {\n  readonly [ERSCIdentityTypeId]: ERSCIdentity<Services>;\n};\n\nexport type ERSCStatefulMember<Services, Kind extends ERSCMemberKind, State> = ERSCMember<\n  Services,\n  Kind\n> & {\n  readonly [ERSCStateTypeId]: State;\n};\n\nexport const makeERSCIdentity = <Services>(): ERSCIdentity<Services> => ({\n  renderRuntime: makeRenderRuntimeContext(),\n});\n\nexport const attachERSCMember = <\n  Member extends object,\n  Services,\n  const Kind extends ERSCMemberKind,\n>(\n  member: Member,\n  identity: ERSCIdentity<Services>,\n  kind: Kind,\n): Member & ERSCMember<Services, Kind> =>\n  Object.assign(member, { [ERSCIdentityTypeId]: identity, [ERSCMemberKindTypeId]: kind });\n\nexport const isERSCMember = <const Kind extends ERSCMemberKind>(\n  value: unknown,\n  kind: Kind,\n): value is ERSCMemberKindMarker<Kind> =>\n  Predicate.hasProperty(value, ERSCMemberKindTypeId) && value[ERSCMemberKindTypeId] === kind;\n\nexport const getERSCIdentity = <Services>(member: ERSCMember<Services>): ERSCIdentity<Services> =>\n  member[ERSCIdentityTypeId];\n"],"names":["Predicate","makeRenderRuntimeContext","ERSCIdentityTypeId","Symbol","ERSCMemberKindTypeId","ERSCStateTypeId","makeERSCIdentity","attachERSCMember","member","identity","kind","Object","isERSCMember","value","getERSCIdentity"],"mappings":";;;;;AAA+C;AAEwC;AAIhF,MAAME,kBAAkBA,GAAkBC,OAAO,GAAG,CAAC,qBAAqB;AAC1E,MAAMC,oBAAoBA,GAAkBD,OAAO,GAAG,CAAC,uBAAuB;AAC9E,MAAME,eAAeA,GAAkBF,OAAO,GAAG,CAAC,kBAAkB;AAoCpE,MAAMG,gBAAgBA,GAAG,IAAyC;QACvE,eAAeL,wBAAwBA;IACzC,GAAG;AAEI,MAAMM,gBAAgBA,GAAG,CAK9BC,QACAC,UACAC,OAEAC,OAAO,MAAM,CAACH,QAAQ;QAAE,CAACN,kBAAkBA,CAAC,EAAEO;QAAU,CAACL,oBAAoBA,CAAC,EAAEM;IAAK,GAAG;AAEnF,MAAME,YAAYA,GAAG,CAC1BC,OACAH,OAEAV,qBAAqB,CAACa,OAAOT,oBAAoBA,KAAKS,KAAK,CAACT,oBAAoBA,CAAC,KAAKM,KAAK;AAEtF,MAAMI,eAAeA,GAAG,CAAWN,SACxCA,MAAM,CAACN,kBAAkBA,CAAC,CAAC"}

package/dist/application/ersc.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentFactory } from './component.js';
+import { type ERSCMake } from './definition.js';
+import { type ERSCMember } from './ersc-identity.js';
+import type { LayoutFactory } from './layout.js';
+import type { LoadingFactory } from './loading.js';
+import { type AnyMiddleware, type MiddlewareFactory, type MiddlewareProvidedServices, type MiddlewareRequiredServices } from './middleware.js';
+import type { PageFactory } from './page.js';
+import type { RoutesFactory } from './routes.js';
+import type { ServerFnFactory } from './server-fn.js';
+type ApplicableMiddleware<AvailableServices, Value> = [
+    Exclude<MiddlewareRequiredServices<Value>, AvailableServices>
+] extends [never] ? unknown : never;
+export type ERSC<ApplicationServices, AvailableServices = ApplicationServices> = ERSCMember<ApplicationServices, 'ERSC'> & {
+    readonly Component: ComponentFactory<ApplicationServices, AvailableServices>;
+    readonly Layout: LayoutFactory<ApplicationServices, AvailableServices>;
+    readonly Loading: LoadingFactory<ApplicationServices>;
+    readonly Middleware: MiddlewareFactory<ApplicationServices, AvailableServices>;
+    readonly Page: PageFactory<ApplicationServices, AvailableServices>;
+    readonly Routes: RoutesFactory<ApplicationServices>;
+    readonly ServerFn: ServerFnFactory<ApplicationServices, AvailableServices>;
+    readonly make: ERSCMake<ApplicationServices>;
+    readonly withMiddleware: <Value extends AnyMiddleware<ApplicationServices>>(middleware: Value & ApplicableMiddleware<AvailableServices, Value>) => ERSC<ApplicationServices, AvailableServices | MiddlewareProvidedServices<Value>>;
+};
+declare const ersc: <Services = never>() => ERSC<Services>;
+export declare const Application: {
+    readonly ersc: typeof ersc;
+};
+export {};

package/dist/application/ersc.js

@@ -0,0 +1,72 @@
+import { makeComponentFactory } from "./component.js";
+import { makeApplication } from "./definition.js";
+import { attachERSCMember, getERSCIdentity, makeERSCIdentity } from "./ersc-identity.js";
+import { makeLayoutFactory } from "./layout.js";
+import { makeLoadingFactory } from "./loading.js";
+import { getMiddlewareState, makeMiddlewareFactory } from "./middleware.js";
+import { makePageFactory } from "./page.js";
+import { makeRoutesFactory } from "./routes.js";
+import { makeServerFnFactory } from "./server-fn.js";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const makeERSC = (identity, middleware, allocateRouteScopeId, make)=>{
+    const withMiddleware = (value)=>{
+        getMiddlewareState(value);
+        if (getERSCIdentity(value) !== identity) {
+            throw new TypeError('Middleware was created by a different ERSC module.');
+        }
+        if (middleware.includes(value)) {
+            throw new TypeError('Middleware cannot appear twice in the same scope.');
+        }
+        return makeERSC(identity, Object.freeze([
+            ...middleware,
+            value
+        ]), allocateRouteScopeId, make);
+    };
+    return Object.freeze(attachERSCMember({
+        Component: makeComponentFactory(identity, middleware),
+        Layout: makeLayoutFactory(identity, middleware),
+        Loading: makeLoadingFactory(identity),
+        Middleware: makeMiddlewareFactory(identity),
+        Page: makePageFactory(identity, middleware),
+        Routes: makeRoutesFactory(identity, middleware, allocateRouteScopeId),
+        ServerFn: makeServerFnFactory(identity, middleware),
+        make,
+        withMiddleware
+    }, identity, 'ERSC'));
+};
+const ersc = ()=>{
+    const identity = makeERSCIdentity();
+    const make = (options)=>makeApplication(identity, options);
+    let nextRouteScopeId = 0;
+    const allocateRouteScopeId = ()=>{
+        const scopeId = nextRouteScopeId;
+        nextRouteScopeId += 1;
+        return scopeId;
+    };
+    return makeERSC(identity, Object.freeze([]), allocateRouteScopeId, make);
+};
+const Application = {
+    ersc: ersc
+};
+
+export { Application };
+
+//# sourceMappingURL=ersc.js.map

package/dist/application/ersc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/ersc.js","sources":["../../src/application/ersc.ts"],"sourcesContent":["import type { ComponentFactory } from './component';\nimport { makeComponentFactory } from './component';\nimport { type ERSCMake, makeApplication } from './definition';\nimport {\n  attachERSCMember,\n  type ERSCIdentity,\n  type ERSCMember,\n  getERSCIdentity,\n  makeERSCIdentity,\n} from './ersc-identity';\nimport type { LayoutFactory } from './layout';\nimport { makeLayoutFactory } from './layout';\nimport type { LoadingFactory } from './loading';\nimport { makeLoadingFactory } from './loading';\nimport {\n  type AnyMiddleware,\n  getMiddlewareState,\n  type MiddlewareFactory,\n  type MiddlewareProvidedServices,\n  type MiddlewareRequiredServices,\n  makeMiddlewareFactory,\n} from './middleware';\nimport type { PageFactory } from './page';\nimport { makePageFactory } from './page';\nimport type { RoutesFactory } from './routes';\nimport { makeRoutesFactory } from './routes';\nimport type { ServerFnFactory } from './server-fn';\nimport { makeServerFnFactory } from './server-fn';\n\ntype ApplicableMiddleware<AvailableServices, Value> = [\n  Exclude<MiddlewareRequiredServices<Value>, AvailableServices>,\n] extends [never]\n  ? unknown\n  : never;\n\nexport type ERSC<ApplicationServices, AvailableServices = ApplicationServices> = ERSCMember<\n  ApplicationServices,\n  'ERSC'\n> & {\n  readonly Component: ComponentFactory<ApplicationServices, AvailableServices>;\n  readonly Layout: LayoutFactory<ApplicationServices, AvailableServices>;\n  readonly Loading: LoadingFactory<ApplicationServices>;\n  readonly Middleware: MiddlewareFactory<ApplicationServices, AvailableServices>;\n  readonly Page: PageFactory<ApplicationServices, AvailableServices>;\n  readonly Routes: RoutesFactory<ApplicationServices>;\n  readonly ServerFn: ServerFnFactory<ApplicationServices, AvailableServices>;\n  readonly make: ERSCMake<ApplicationServices>;\n  readonly withMiddleware: <Value extends AnyMiddleware<ApplicationServices>>(\n    middleware: Value & ApplicableMiddleware<AvailableServices, Value>,\n  ) => ERSC<ApplicationServices, AvailableServices | MiddlewareProvidedServices<Value>>;\n};\n\nconst makeERSC = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n  allocateRouteScopeId: () => number,\n  make: ERSCMake<ApplicationServices>,\n): ERSC<ApplicationServices, AvailableServices> => {\n  const withMiddleware = <Value extends AnyMiddleware<ApplicationServices>>(\n    value: Value & ApplicableMiddleware<AvailableServices, Value>,\n  ): ERSC<ApplicationServices, AvailableServices | MiddlewareProvidedServices<Value>> => {\n    getMiddlewareState(value);\n    if (getERSCIdentity(value) !== identity) {\n      throw new TypeError('Middleware was created by a different ERSC module.');\n    }\n    if (middleware.includes(value)) {\n      throw new TypeError('Middleware cannot appear twice in the same scope.');\n    }\n\n    return makeERSC(identity, Object.freeze([...middleware, value]), allocateRouteScopeId, make);\n  };\n\n  return Object.freeze(\n    attachERSCMember(\n      {\n        Component: makeComponentFactory<ApplicationServices, AvailableServices>(\n          identity,\n          middleware,\n        ),\n        Layout: makeLayoutFactory<ApplicationServices, AvailableServices>(identity, middleware),\n        Loading: makeLoadingFactory(identity),\n        Middleware: makeMiddlewareFactory<ApplicationServices, AvailableServices>(identity),\n        Page: makePageFactory<ApplicationServices, AvailableServices>(identity, middleware),\n        Routes: makeRoutesFactory(identity, middleware, allocateRouteScopeId),\n        ServerFn: makeServerFnFactory<ApplicationServices, AvailableServices>(identity, middleware),\n        make,\n        withMiddleware,\n      },\n      identity,\n      'ERSC',\n    ),\n  );\n};\n\nconst ersc = <Services = never>(): ERSC<Services> => {\n  const identity = makeERSCIdentity<Services>();\n  const make: ERSCMake<Services> = (options) => makeApplication(identity, options);\n  let nextRouteScopeId = 0;\n  const allocateRouteScopeId = () => {\n    const scopeId = nextRouteScopeId;\n    nextRouteScopeId += 1;\n    return scopeId;\n  };\n\n  return makeERSC(identity, Object.freeze([]), allocateRouteScopeId, make);\n};\n\nexport const Application = { ersc } as const;\n"],"names":["makeComponentFactory","makeApplication","attachERSCMember","getERSCIdentity","makeERSCIdentity","makeLayoutFactory","makeLoadingFactory","getMiddlewareState","makeMiddlewareFactory","makePageFactory","makeRoutesFactory","makeServerFnFactory","makeERSC","identity","middleware","allocateRouteScopeId","make","withMiddleware","value","TypeError","Object","ersc","options","nextRouteScopeId","scopeId","Application"],"mappings":";;;;;;;;;;;;;;;;;;;AACmD;AACW;AAOrC;AAEoB;AAEE;AAQzB;AAEmB;AAEI;AAEK;AAyBlD,MAAMY,QAAQA,GAAG,CACfC,UACAC,YACAC,sBACAC;IAEA,MAAMC,iBAAiB,CACrBC;QAEAX,kBAAkBA,CAACW;QACnB,IAAIf,eAAeA,CAACe,WAAWL,UAAU;YACvC,MAAM,IAAIM,UAAU;QACtB;QACA,IAAIL,WAAW,QAAQ,CAACI,QAAQ;YAC9B,MAAM,IAAIC,UAAU;QACtB;QAEA,OAAOP,QAAQA,CAACC,UAAUO,OAAO,MAAM,CAAC;eAAIN;YAAYI;SAAM,GAAGH,sBAAsBC;IACzF;IAEA,OAAOI,OAAO,MAAM,CAClBlB,gBAAgBA,CACd;QACE,WAAWF,oBAAoBA,CAC7Ba,UACAC;QAEF,QAAQT,iBAAiBA,CAAyCQ,UAAUC;QAC5E,SAASR,kBAAkBA,CAACO;QAC5B,YAAYL,qBAAqBA,CAAyCK;QAC1E,MAAMJ,eAAeA,CAAyCI,UAAUC;QACxE,QAAQJ,iBAAiBA,CAACG,UAAUC,YAAYC;QAChD,UAAUJ,mBAAmBA,CAAyCE,UAAUC;QAChFE;QACAC;IACF,GACAJ,UACA;AAGN;AAEA,MAAMQ,IAAIA,GAAG;IACX,MAAMR,WAAWT,gBAAgBA;IACjC,MAAMY,OAA2B,CAACM,UAAYrB,eAAeA,CAACY,UAAUS;IACxE,IAAIC,mBAAmB;IACvB,MAAMR,uBAAuB;QAC3B,MAAMS,UAAUD;QAChBA,oBAAoB;QACpB,OAAOC;IACT;IAEA,OAAOZ,QAAQA,CAACC,UAAUO,OAAO,MAAM,CAAC,EAAE,GAAGL,sBAAsBC;AACrE;AAEO,MAAMS,WAAWA,GAAG;IAAEJ,UAAIA;AAAC,EAAW"}

package/dist/application/layout.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from 'effect';
+import type { ReactNode } from 'react';
+import { type ERSCIdentity, type ERSCMember } from './ersc-identity.js';
+import type { AnyMiddleware } from './middleware.js';
+type LayoutProps = {
+    readonly children: Awaited<ReactNode>;
+};
+export interface LayoutComponent<ApplicationServices> extends ERSCMember<ApplicationServices, 'Layout'> {
+    (props: LayoutProps): Promise<Awaited<ReactNode>>;
+}
+type LayoutOptions<Error, AvailableServices> = {
+    readonly render: (props: LayoutProps) => Effect.Effect<Awaited<ReactNode>, Error, AvailableServices>;
+};
+export type LayoutFactory<ApplicationServices, AvailableServices> = {
+    readonly make: <Error>(options: LayoutOptions<Error, AvailableServices>) => LayoutComponent<ApplicationServices>;
+};
+export declare const makeLayoutFactory: <ApplicationServices, AvailableServices>(identity: ERSCIdentity<ApplicationServices>, middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>) => LayoutFactory<ApplicationServices, AvailableServices>;
+export {};

package/dist/application/layout.js

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import { attachERSCMember } from "./ersc-identity.js";
+
+
+
+
+
+const makeLayoutFactory = (identity, middleware)=>({
+        make: ({ render })=>{
+            const LayoutComponent = (props)=>identity.renderRuntime.run('Layout', Effect.suspend(()=>render(props)), middleware);
+            return attachERSCMember(LayoutComponent, identity, 'Layout');
+        }
+    });
+
+export { makeLayoutFactory };
+
+//# sourceMappingURL=layout.js.map

package/dist/application/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/layout.js","sources":["../../src/application/layout.ts"],"sourcesContent":["import { Effect } from 'effect';\nimport type { ReactNode } from 'react';\n\nimport { attachERSCMember, type ERSCIdentity, type ERSCMember } from './ersc-identity';\nimport type { AnyMiddleware } from './middleware';\n\ntype LayoutProps = {\n  readonly children: Awaited<ReactNode>;\n};\n\nexport interface LayoutComponent<ApplicationServices> extends ERSCMember<\n  ApplicationServices,\n  'Layout'\n> {\n  (props: LayoutProps): Promise<Awaited<ReactNode>>;\n}\n\ntype LayoutOptions<Error, AvailableServices> = {\n  readonly render: (\n    props: LayoutProps,\n  ) => Effect.Effect<Awaited<ReactNode>, Error, AvailableServices>;\n};\n\nexport type LayoutFactory<ApplicationServices, AvailableServices> = {\n  readonly make: <Error>(\n    options: LayoutOptions<Error, AvailableServices>,\n  ) => LayoutComponent<ApplicationServices>;\n};\n\nexport const makeLayoutFactory = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n): LayoutFactory<ApplicationServices, AvailableServices> => ({\n  make: ({ render }) => {\n    const LayoutComponent = (props: LayoutProps) =>\n      identity.renderRuntime.run(\n        'Layout',\n        Effect.suspend(() => render(props)),\n        middleware,\n      );\n\n    return attachERSCMember(LayoutComponent, identity, 'Layout');\n  },\n});\n"],"names":["Effect","attachERSCMember","makeLayoutFactory","identity","middleware","render","LayoutComponent","props"],"mappings":";;;;;AAAgC;AAGuD;AA0BhF,MAAME,iBAAiBA,GAAG,CAC/BC,UACAC,aAC2D;QAC3D,MAAM,CAAC,EAAEC,MAAM,EAAE;YACf,MAAMC,kBAAkB,CAACC,QACvBJ,SAAS,aAAa,CAAC,GAAG,CACxB,UACAH,cAAc,CAAC,IAAMK,OAAOE,SAC5BH;YAGJ,OAAOH,gBAAgBA,CAACK,iBAAiBH,UAAU;QACrD;IACF,GAAG"}

package/dist/application/loading.d.ts

@@ -0,0 +1,17 @@
+import { type Effect } from 'effect';
+import type { ReactNode } from 'react';
+import { type ERSCIdentity, type ERSCMember } from './ersc-identity.js';
+export interface LoadingComponent<Services> extends ERSCMember<Services, 'Loading'> {
+    (): Awaited<ReactNode>;
+}
+type NonEffectOutput<Output> = [Extract<Output, Effect.Effect<unknown, unknown, unknown>>] extends [
+    never
+] ? unknown : never;
+type LoadingOptions<Output extends Awaited<ReactNode>> = {
+    readonly render: (() => Output) & NonEffectOutput<Output>;
+};
+export type LoadingFactory<Services> = {
+    readonly make: <Output extends Awaited<ReactNode>>(options: LoadingOptions<Output>) => LoadingComponent<Services>;
+};
+export declare const makeLoadingFactory: <Services>(identity: ERSCIdentity<Services>) => LoadingFactory<Services>;
+export {};

package/dist/application/loading.js

@@ -0,0 +1,14 @@
+import { attachERSCMember } from "./ersc-identity.js";
+
+
+
+const makeLoadingFactory = (identity)=>({
+        make: ({ render })=>{
+            const LoadingComponent = ()=>render();
+            return attachERSCMember(LoadingComponent, identity, 'Loading');
+        }
+    });
+
+export { makeLoadingFactory };
+
+//# sourceMappingURL=loading.js.map

package/dist/application/loading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/loading.js","sources":["../../src/application/loading.ts"],"sourcesContent":["import { type Effect } from 'effect';\nimport type { ReactNode } from 'react';\n\nimport { attachERSCMember, type ERSCIdentity, type ERSCMember } from './ersc-identity';\n\nexport interface LoadingComponent<Services> extends ERSCMember<Services, 'Loading'> {\n  (): Awaited<ReactNode>;\n}\n\ntype NonEffectOutput<Output> = [Extract<Output, Effect.Effect<unknown, unknown, unknown>>] extends [\n  never,\n]\n  ? unknown\n  : never;\n\ntype LoadingOptions<Output extends Awaited<ReactNode>> = {\n  readonly render: (() => Output) & NonEffectOutput<Output>;\n};\n\nexport type LoadingFactory<Services> = {\n  readonly make: <Output extends Awaited<ReactNode>>(\n    options: LoadingOptions<Output>,\n  ) => LoadingComponent<Services>;\n};\n\nexport const makeLoadingFactory = <Services>(\n  identity: ERSCIdentity<Services>,\n): LoadingFactory<Services> => ({\n  make: ({ render }) => {\n    const LoadingComponent = () => render();\n    return attachERSCMember(LoadingComponent, identity, 'Loading');\n  },\n});\n"],"names":["attachERSCMember","makeLoadingFactory","identity","render","LoadingComponent"],"mappings":";;;AAGuF;AAsBhF,MAAMC,kBAAkBA,GAAG,CAChCC,WAC8B;QAC9B,MAAM,CAAC,EAAEC,MAAM,EAAE;YACf,MAAMC,mBAAmB,IAAMD;YAC/B,OAAOH,gBAAgBA,CAACI,kBAAkBF,UAAU;QACtD;IACF,GAAG"}

package/dist/application/middleware.d.ts

@@ -0,0 +1,36 @@
+import { type Effect } from 'effect';
+import { HttpRouter, type HttpServerResponse } from 'effect/unstable/http';
+import { type ERSCIdentity, type ERSCStatefulMember } from './ersc-identity.js';
+type MiddlewareConfig = {
+    readonly provides?: unknown;
+};
+type MiddlewareProvides<Config extends MiddlewareConfig> = Config extends {
+    readonly provides: infer Provides;
+} ? Provides : never;
+type MiddlewareHandler<AvailableServices, Provides> = <Error, RemainingServices>(httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, Error, Provides | RemainingServices>) => Effect.Effect<HttpServerResponse.HttpServerResponse, Error, AvailableServices | HttpRouter.Provided | RemainingServices>;
+export interface Middleware<ApplicationServices, out RequiredServices, out ProvidedServices> extends ERSCStatefulMember<ApplicationServices, 'Middleware', MiddlewareImplementationState<RequiredServices, ProvidedServices>> {
+}
+export type AnyMiddleware<ApplicationServices> = Middleware<ApplicationServices, unknown, unknown>;
+type HttpMiddleware<RequiredServices, ProvidedServices> = HttpRouter.Middleware<{
+    readonly error: never;
+    readonly handles: never;
+    readonly layerError: never;
+    readonly layerRequires: never;
+    readonly provides: ProvidedServices;
+    readonly requires: Exclude<RequiredServices, HttpRouter.Provided>;
+}>;
+export type MiddlewareImplementationState<RequiredServices, ProvidedServices> = {
+    readonly handler: MiddlewareHandler<RequiredServices, ProvidedServices>;
+    readonly httpMiddleware: HttpMiddleware<RequiredServices, ProvidedServices>;
+};
+export declare const getMiddlewareState: <ApplicationServices, RequiredServices, ProvidedServices>(middleware: Middleware<ApplicationServices, RequiredServices, ProvidedServices>) => MiddlewareImplementationState<RequiredServices, ProvidedServices>;
+export declare const getScopedMiddlewareHandler: <ApplicationServices>(middleware: AnyMiddleware<ApplicationServices>) => MiddlewareHandler<ApplicationServices | HttpRouter.Provided, never>;
+export declare const applyMiddleware: <ApplicationServices, Error, RemainingServices>(middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>, httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, Error, ApplicationServices | HttpRouter.Provided | RemainingServices>) => Effect.Effect<HttpServerResponse.HttpServerResponse, Error, ApplicationServices | RemainingServices | HttpRouter.Provided>;
+export declare function getScopedHttpMiddleware<ApplicationServices>(middleware: AnyMiddleware<ApplicationServices>): HttpMiddleware<never, never>;
+export type MiddlewareFactory<ApplicationServices, AvailableServices> = {
+    readonly make: <Config extends MiddlewareConfig = {}>(handler: MiddlewareHandler<AvailableServices, MiddlewareProvides<Config>>) => Middleware<ApplicationServices, AvailableServices, MiddlewareProvides<Config>>;
+};
+export declare const makeMiddlewareFactory: <ApplicationServices, AvailableServices>(identity: ERSCIdentity<ApplicationServices>) => MiddlewareFactory<ApplicationServices, AvailableServices>;
+export type MiddlewareProvidedServices<Value> = Value extends Middleware<infer _ApplicationServices, infer _RequiredServices, infer ProvidedServices> ? ProvidedServices : never;
+export type MiddlewareRequiredServices<Value> = Value extends Middleware<infer _ApplicationServices, infer RequiredServices, infer _ProvidedServices> ? RequiredServices : never;
+export {};

package/dist/application/middleware.js

@@ -0,0 +1,46 @@
+import { HttpRouter } from "effect/unstable/http";
+import { ERSCIdentityTypeId, ERSCMemberKindTypeId, ERSCStateTypeId, isERSCMember } from "./ersc-identity.js";
+
+
+
+
+
+class MiddlewareImpl {
+    [ERSCIdentityTypeId];
+    [ERSCMemberKindTypeId] = 'Middleware';
+    get [ERSCStateTypeId]() {
+        return this;
+    }
+    handler;
+    httpMiddleware;
+    constructor(identity, handler, httpMiddleware){
+        this[ERSCIdentityTypeId] = identity;
+        this.handler = handler;
+        this.httpMiddleware = httpMiddleware;
+        Object.freeze(this);
+    }
+}
+const getMiddlewareState = (middleware)=>{
+    if (!isERSCMember(middleware, 'Middleware')) {
+        throw new TypeError('Middleware must be created with ERSC.Middleware.make.');
+    }
+    return middleware[ERSCStateTypeId];
+};
+const getScopedMiddlewareHandler = (middleware)=>getMiddlewareState(middleware).handler;
+const applyMiddleware = (middleware, httpEffect)=>middleware.reduceRight((current, value)=>getScopedMiddlewareHandler(value)(current), httpEffect);
+// AnyMiddleware erases each link's service contract after withMiddleware has validated the ordered
+// chain. Callers must compose that complete chain inside the application and request context; the
+// returned native descriptor retains the real runtime provisioning behavior.
+function getScopedHttpMiddleware(middleware) {
+    return getMiddlewareState(middleware).httpMiddleware;
+}
+const makeMiddlewareFactory = (identity)=>({
+        make: (handler)=>{
+            const httpHandler = (httpEffect)=>handler(httpEffect);
+            return new MiddlewareImpl(identity, handler, HttpRouter.middleware()(httpHandler));
+        }
+    });
+
+export { applyMiddleware, getMiddlewareState, getScopedHttpMiddleware, getScopedMiddlewareHandler, makeMiddlewareFactory };
+
+//# sourceMappingURL=middleware.js.map

package/dist/application/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/middleware.js","sources":["../../src/application/middleware.ts"],"sourcesContent":["import { type Effect, type Types } from 'effect';\nimport { HttpRouter, type HttpServerResponse } from 'effect/unstable/http';\n\nimport {\n  type ERSCIdentity,\n  ERSCIdentityTypeId,\n  isERSCMember,\n  ERSCMemberKindTypeId,\n  type ERSCStatefulMember,\n  ERSCStateTypeId,\n} from './ersc-identity';\n\ntype MiddlewareConfig = {\n  readonly provides?: unknown;\n};\n\ntype MiddlewareProvides<Config extends MiddlewareConfig> = Config extends {\n  readonly provides: infer Provides;\n}\n  ? Provides\n  : never;\n\ntype MiddlewareHandler<AvailableServices, Provides> = <Error, RemainingServices>(\n  httpEffect: Effect.Effect<\n    HttpServerResponse.HttpServerResponse,\n    Error,\n    Provides | RemainingServices\n  >,\n) => Effect.Effect<\n  HttpServerResponse.HttpServerResponse,\n  Error,\n  AvailableServices | HttpRouter.Provided | RemainingServices\n>;\n\nexport interface Middleware<\n  ApplicationServices,\n  out RequiredServices,\n  out ProvidedServices,\n> extends ERSCStatefulMember<\n  ApplicationServices,\n  'Middleware',\n  MiddlewareImplementationState<RequiredServices, ProvidedServices>\n> {}\n\nexport type AnyMiddleware<ApplicationServices> = Middleware<ApplicationServices, unknown, unknown>;\n\ntype HttpMiddleware<RequiredServices, ProvidedServices> = HttpRouter.Middleware<{\n  readonly error: never;\n  readonly handles: never;\n  readonly layerError: never;\n  readonly layerRequires: never;\n  readonly provides: ProvidedServices;\n  readonly requires: Exclude<RequiredServices, HttpRouter.Provided>;\n}>;\n\nexport type MiddlewareImplementationState<RequiredServices, ProvidedServices> = {\n  // Page GET/HEAD composes the native descriptor so Effect HTTP retains routing semantics such as\n  // HEAD fallback. Server Function POST keeps the handler because its scope is known only after\n  // React decodes the invoked reference.\n  readonly handler: MiddlewareHandler<RequiredServices, ProvidedServices>;\n  readonly httpMiddleware: HttpMiddleware<RequiredServices, ProvidedServices>;\n};\n\nclass MiddlewareImpl<ApplicationServices, RequiredServices, ProvidedServices>\n  implements\n    Middleware<ApplicationServices, RequiredServices, ProvidedServices>,\n    MiddlewareImplementationState<RequiredServices, ProvidedServices>\n{\n  readonly [ERSCIdentityTypeId]: ERSCIdentity<ApplicationServices>;\n  readonly [ERSCMemberKindTypeId] = 'Middleware' as const;\n  get [ERSCStateTypeId](): MiddlewareImplementationState<RequiredServices, ProvidedServices> {\n    return this;\n  }\n  readonly handler: MiddlewareHandler<RequiredServices, ProvidedServices>;\n  readonly httpMiddleware: HttpMiddleware<RequiredServices, ProvidedServices>;\n\n  constructor(\n    identity: ERSCIdentity<ApplicationServices>,\n    handler: MiddlewareHandler<RequiredServices, ProvidedServices>,\n    httpMiddleware: HttpMiddleware<RequiredServices, ProvidedServices>,\n  ) {\n    this[ERSCIdentityTypeId] = identity;\n    this.handler = handler;\n    this.httpMiddleware = httpMiddleware;\n    Object.freeze(this);\n  }\n}\n\nexport const getMiddlewareState = <ApplicationServices, RequiredServices, ProvidedServices>(\n  middleware: Middleware<ApplicationServices, RequiredServices, ProvidedServices>,\n): MiddlewareImplementationState<RequiredServices, ProvidedServices> => {\n  if (!isERSCMember(middleware, 'Middleware')) {\n    throw new TypeError('Middleware must be created with ERSC.Middleware.make.');\n  }\n  return middleware[ERSCStateTypeId];\n};\n\nexport const getScopedMiddlewareHandler = <ApplicationServices>(\n  middleware: AnyMiddleware<ApplicationServices>,\n): MiddlewareHandler<ApplicationServices | HttpRouter.Provided, never> =>\n  getMiddlewareState(middleware).handler;\n\nexport const applyMiddleware = <ApplicationServices, Error, RemainingServices>(\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n  httpEffect: Effect.Effect<\n    HttpServerResponse.HttpServerResponse,\n    Error,\n    ApplicationServices | HttpRouter.Provided | RemainingServices\n  >,\n) =>\n  middleware.reduceRight(\n    (current, value) => getScopedMiddlewareHandler(value)(current),\n    httpEffect,\n  );\n\nexport function getScopedHttpMiddleware<ApplicationServices>(\n  middleware: AnyMiddleware<ApplicationServices>,\n): HttpMiddleware<never, never>;\n// AnyMiddleware erases each link's service contract after withMiddleware has validated the ordered\n// chain. Callers must compose that complete chain inside the application and request context; the\n// returned native descriptor retains the real runtime provisioning behavior.\nexport function getScopedHttpMiddleware(middleware: AnyMiddleware<unknown>) {\n  return getMiddlewareState(middleware).httpMiddleware;\n}\n\nexport type MiddlewareFactory<ApplicationServices, AvailableServices> = {\n  readonly make: <Config extends MiddlewareConfig = {}>(\n    handler: MiddlewareHandler<AvailableServices, MiddlewareProvides<Config>>,\n  ) => Middleware<ApplicationServices, AvailableServices, MiddlewareProvides<Config>>;\n};\n\nexport const makeMiddlewareFactory = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n): MiddlewareFactory<ApplicationServices, AvailableServices> => ({\n  make: <Config extends MiddlewareConfig = {}>(\n    handler: MiddlewareHandler<AvailableServices, MiddlewareProvides<Config>>,\n  ): Middleware<ApplicationServices, AvailableServices, MiddlewareProvides<Config>> => {\n    type Provides = MiddlewareProvides<Config>;\n    const httpHandler = (\n      httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, Types.unhandled, Provides>,\n    ) => handler<Types.unhandled, never>(httpEffect);\n    return new MiddlewareImpl(\n      identity,\n      handler,\n      HttpRouter.middleware<{ provides: Provides }>()(httpHandler),\n    );\n  },\n});\n\nexport type MiddlewareProvidedServices<Value> =\n  Value extends Middleware<\n    infer _ApplicationServices,\n    infer _RequiredServices,\n    infer ProvidedServices\n  >\n    ? ProvidedServices\n    : never;\n\nexport type MiddlewareRequiredServices<Value> =\n  Value extends Middleware<\n    infer _ApplicationServices,\n    infer RequiredServices,\n    infer _ProvidedServices\n  >\n    ? RequiredServices\n    : never;\n"],"names":["HttpRouter","ERSCIdentityTypeId","isERSCMember","ERSCMemberKindTypeId","ERSCStateTypeId","MiddlewareImpl","identity","handler","httpMiddleware","Object","getMiddlewareState","middleware","TypeError","getScopedMiddlewareHandler","applyMiddleware","httpEffect","current","value","getScopedHttpMiddleware","makeMiddlewareFactory","httpHandler"],"mappings":";;;;;AAC2E;AASlD;AAqDzB,MAAMK,cAAcA;IAKT,CAACJ,kBAAkBA,CAAC,CAAoC;IACxD,CAACE,oBAAoBA,CAAC,GAAG,aAAsB;IACxD,IAAI,CAACC,eAAeA,CAAC,GAAsE;QACzF,OAAO,IAAI;IACb;IACS,QAA+D;IAC/D,eAAmE;IAE5E,YACEE,QAA2C,EAC3CC,OAA8D,EAC9DC,cAAkE,CAClE;QACA,IAAI,CAACP,kBAAkBA,CAAC,GAAGK;QAC3B,IAAI,CAAC,OAAO,GAAGC;QACf,IAAI,CAAC,cAAc,GAAGC;QACtBC,OAAO,MAAM,CAAC,IAAI;IACpB;AACF;AAEO,MAAMC,kBAAkBA,GAAG,CAChCC;IAEA,IAAI,CAACT,YAAYA,CAACS,YAAY,eAAe;QAC3C,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOD,UAAU,CAACP,eAAeA,CAAC;AACpC,EAAE;AAEK,MAAMS,0BAA0BA,GAAG,CACxCF,aAEAD,kBAAkBA,CAACC,YAAY,OAAO,CAAC;AAElC,MAAMG,eAAeA,GAAG,CAC7BH,YACAI,aAMAJ,WAAW,WAAW,CACpB,CAACK,SAASC,QAAUJ,0BAA0BA,CAACI,OAAOD,UACtDD,YACA;AAKJ,mGAAmG;AACnG,kGAAkG;AAClG,6EAA6E;AACtE,SAASG,uBAAuBA,CAACP,UAAkC;IACxE,OAAOD,kBAAkBA,CAACC,YAAY,cAAc;AACtD;AAQO,MAAMQ,qBAAqBA,GAAG,CACnCb,WAC+D;QAC/D,MAAM,CACJC;YAGA,MAAMa,cAAc,CAClBL,aACGR,QAAgCQ;YACrC,OAAO,IAAIV,cAAcA,CACvBC,UACAC,SACAP,qBAAqB,GAA2BoB;QAEpD;IACF,GAAG"}

package/dist/application/page.d.ts

@@ -0,0 +1,58 @@
+import { Effect, Schema, type Types } from 'effect';
+import type { ReactNode } from 'react';
+import { type ERSCIdentity, type ERSCStatefulMember } from './ersc-identity.js';
+import type { AnyMiddleware } from './middleware.js';
+import type { ValidRouteParamName } from './route-path.js';
+declare const PageContractTypeId: unique symbol;
+export type PageParamsSchema<Services> = Schema.ConstraintCodec<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Services, unknown>;
+type PageParamKeys<ParamsSchema> = ParamsSchema extends {
+    readonly Encoded: infer Encoded;
+} ? Extract<keyof Encoded, string> : never;
+type NonStringPageParamKeys<ParamsSchema> = ParamsSchema extends {
+    readonly Encoded: infer Encoded;
+} ? Exclude<keyof Encoded, string> : never;
+type InvalidPageParamName<Name extends string> = Name extends ValidRouteParamName<Name> ? never : Name;
+type InvalidPageParamValueKeys<ParamsSchema> = ParamsSchema extends {
+    readonly Encoded: infer Encoded;
+} ? {
+    [Key in Extract<keyof Encoded, string>]-?: unknown extends Encoded[Key] ? never : [Extract<Encoded[Key], string>] extends [never] ? Key : never;
+}[Extract<keyof Encoded, string>] : never;
+type InvalidPageParamsSchema<ParamsSchema> = NonStringPageParamKeys<ParamsSchema> | InvalidPageParamName<PageParamKeys<ParamsSchema>> | InvalidPageParamValueKeys<ParamsSchema>;
+type ValidPageParamsSchema<ParamsSchema> = [PageParamKeys<ParamsSchema>] extends [never] ? never : string extends PageParamKeys<ParamsSchema> ? never : [InvalidPageParamsSchema<ParamsSchema>] extends [never] ? unknown : never;
+export type PageConcern<out ParamNames extends string, out Mode extends 'Parameterized' | 'Static'> = {
+    readonly [PageContractTypeId]: {
+        readonly mode: Types.Covariant<Mode>;
+        readonly paramNames: Types.Covariant<ParamNames>;
+    };
+};
+export type PagePathParams = Readonly<Record<string, string | undefined>>;
+export type PageRuntimeProps<ParamNames extends string = string> = {
+    readonly params: Readonly<Record<ParamNames, string | undefined>>;
+};
+export type PageComponent<ParamNames extends string = string> = (props: PageRuntimeProps<ParamNames>) => Promise<Awaited<ReactNode>>;
+export type StaticPageDefinition<Services> = ERSCStatefulMember<Services, 'Page', PageImplementationState> & PageConcern<never, 'Static'>;
+export type ParameterizedPageDefinition<Services, ParamNames extends string = string> = ERSCStatefulMember<Services, 'Page', PageImplementationState> & PageConcern<ParamNames, 'Parameterized'>;
+export type AnyPageDefinition<Services> = StaticPageDefinition<Services> | ParameterizedPageDefinition<Services>;
+export type PageImplementationState = {
+    readonly component: PageComponent;
+    readonly paramsSchema: Schema.Constraint | null;
+};
+export declare const getPageState: <Services>(page: AnyPageDefinition<Services>) => PageImplementationState;
+type StaticPageOptions<Error, Services> = {
+    readonly params?: never;
+    readonly render: () => Effect.Effect<Awaited<ReactNode>, Error, Services>;
+};
+type ParameterizedPageOptions<ParamsSchema extends PageParamsSchema<Services>, Error, Services> = {
+    readonly params: ParamsSchema;
+    readonly render: (props: {
+        readonly params: ParamsSchema['Type'];
+    }) => Effect.Effect<Awaited<ReactNode>, Error, Services>;
+};
+export type PageFactory<ApplicationServices, AvailableServices> = {
+    readonly make: {
+        <ParamsSchema extends PageParamsSchema<AvailableServices>, Error>(options: ParameterizedPageOptions<ParamsSchema, Error, AvailableServices> & ValidPageParamsSchema<ParamsSchema>): ParameterizedPageDefinition<ApplicationServices, PageParamKeys<ParamsSchema>>;
+        <Error>(options: StaticPageOptions<Error, AvailableServices>): StaticPageDefinition<ApplicationServices>;
+    };
+};
+export declare const makePageFactory: <ApplicationServices, AvailableServices>(identity: ERSCIdentity<ApplicationServices>, middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>) => PageFactory<ApplicationServices, AvailableServices>;
+export {};

package/dist/application/page.js

@@ -0,0 +1,50 @@
+import { Effect, Schema } from "effect";
+import { ERSCIdentityTypeId, ERSCMemberKindTypeId, ERSCStateTypeId, isERSCMember } from "./ersc-identity.js";
+
+
+
+
+
+class PageDefinitionImpl {
+    [ERSCIdentityTypeId];
+    [ERSCMemberKindTypeId] = 'Page';
+    get [ERSCStateTypeId]() {
+        return this;
+    }
+    component;
+    paramsSchema;
+    constructor(identity, component, paramsSchema){
+        this[ERSCIdentityTypeId] = identity;
+        this.component = component;
+        this.paramsSchema = paramsSchema;
+        Object.freeze(this);
+    }
+}
+const getPageState = (page)=>{
+    if (!isERSCMember(page, 'Page')) {
+        throw new TypeError('Page must be created with ERSC.Page.make.');
+    }
+    return page[ERSCStateTypeId];
+};
+const makePageFactory = (identity, middleware)=>{
+    function make(options) {
+        if ('params' in options) {
+            const { params: paramsSchema, render } = options;
+            const decodeParams = Schema.decodeUnknownEffect(paramsSchema);
+            const component = ({ params })=>identity.renderRuntime.run('Page', decodeParams(params).pipe(Effect.flatMap((decodedParams)=>Effect.suspend(()=>render({
+                            params: decodedParams
+                        })))), middleware);
+            return new PageDefinitionImpl(identity, component, paramsSchema);
+        }
+        const { render } = options;
+        const component = ()=>identity.renderRuntime.run('Page', Effect.suspend(render), middleware);
+        return new PageDefinitionImpl(identity, component, null);
+    }
+    return {
+        make
+    };
+};
+
+export { getPageState, makePageFactory };
+
+//# sourceMappingURL=page.js.map

package/dist/application/page.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application/page.js","sources":["../../src/application/page.ts"],"sourcesContent":["import { Effect, Schema, type Types } from 'effect';\nimport type { ReactNode } from 'react';\n\nimport {\n  type ERSCIdentity,\n  ERSCIdentityTypeId,\n  isERSCMember,\n  ERSCMemberKindTypeId,\n  type ERSCStatefulMember,\n  ERSCStateTypeId,\n} from './ersc-identity';\nimport type { AnyMiddleware } from './middleware';\nimport type { ValidRouteParamName } from './route-path';\n\ndeclare const PageContractTypeId: unique symbol;\n\nexport type PageParamsSchema<Services> = Schema.ConstraintCodec<\n  Readonly<Record<string, unknown>>,\n  Readonly<Record<string, unknown>>,\n  Services,\n  unknown\n>;\n\ntype PageParamKeys<ParamsSchema> = ParamsSchema extends { readonly Encoded: infer Encoded }\n  ? Extract<keyof Encoded, string>\n  : never;\ntype NonStringPageParamKeys<ParamsSchema> = ParamsSchema extends {\n  readonly Encoded: infer Encoded;\n}\n  ? Exclude<keyof Encoded, string>\n  : never;\ntype InvalidPageParamName<Name extends string> =\n  Name extends ValidRouteParamName<Name> ? never : Name;\ntype InvalidPageParamValueKeys<ParamsSchema> = ParamsSchema extends {\n  readonly Encoded: infer Encoded;\n}\n  ? {\n      [Key in Extract<keyof Encoded, string>]-?: unknown extends Encoded[Key]\n        ? never\n        : [Extract<Encoded[Key], string>] extends [never]\n          ? Key\n          : never;\n    }[Extract<keyof Encoded, string>]\n  : never;\ntype InvalidPageParamsSchema<ParamsSchema> =\n  | NonStringPageParamKeys<ParamsSchema>\n  | InvalidPageParamName<PageParamKeys<ParamsSchema>>\n  | InvalidPageParamValueKeys<ParamsSchema>;\ntype ValidPageParamsSchema<ParamsSchema> = [PageParamKeys<ParamsSchema>] extends [never]\n  ? never\n  : string extends PageParamKeys<ParamsSchema>\n    ? never\n    : [InvalidPageParamsSchema<ParamsSchema>] extends [never]\n      ? unknown\n      : never;\n\nexport type PageConcern<\n  out ParamNames extends string,\n  out Mode extends 'Parameterized' | 'Static',\n> = {\n  readonly [PageContractTypeId]: {\n    readonly mode: Types.Covariant<Mode>;\n    readonly paramNames: Types.Covariant<ParamNames>;\n  };\n};\n\nexport type PagePathParams = Readonly<Record<string, string | undefined>>;\nexport type PageRuntimeProps<ParamNames extends string = string> = {\n  readonly params: Readonly<Record<ParamNames, string | undefined>>;\n};\nexport type PageComponent<ParamNames extends string = string> = (\n  props: PageRuntimeProps<ParamNames>,\n) => Promise<Awaited<ReactNode>>;\n\nexport type StaticPageDefinition<Services> = ERSCStatefulMember<\n  Services,\n  'Page',\n  PageImplementationState\n> &\n  PageConcern<never, 'Static'>;\nexport type ParameterizedPageDefinition<\n  Services,\n  ParamNames extends string = string,\n> = ERSCStatefulMember<Services, 'Page', PageImplementationState> &\n  PageConcern<ParamNames, 'Parameterized'>;\nexport type AnyPageDefinition<Services> =\n  | StaticPageDefinition<Services>\n  | ParameterizedPageDefinition<Services>;\n\nexport type PageImplementationState = {\n  readonly component: PageComponent;\n  readonly paramsSchema: Schema.Constraint | null;\n};\n\nclass PageDefinitionImpl<\n  Services,\n  ParamNames extends string,\n  Mode extends 'Parameterized' | 'Static',\n  ParamsSchema extends Schema.Constraint | null,\n>\n  implements\n    ERSCStatefulMember<Services, 'Page', PageImplementationState>,\n    PageConcern<ParamNames, Mode>\n{\n  declare readonly [PageContractTypeId]: {\n    readonly mode: Types.Covariant<Mode>;\n    readonly paramNames: Types.Covariant<ParamNames>;\n  };\n  readonly [ERSCIdentityTypeId]: ERSCIdentity<Services>;\n  readonly [ERSCMemberKindTypeId] = 'Page' as const;\n  get [ERSCStateTypeId](): PageImplementationState {\n    return this;\n  }\n  readonly component: PageComponent;\n  readonly paramsSchema: ParamsSchema;\n\n  constructor(\n    identity: ERSCIdentity<Services>,\n    component: PageComponent,\n    paramsSchema: ParamsSchema,\n  ) {\n    this[ERSCIdentityTypeId] = identity;\n    this.component = component;\n    this.paramsSchema = paramsSchema;\n    Object.freeze(this);\n  }\n}\n\nexport const getPageState = <Services>(\n  page: AnyPageDefinition<Services>,\n): PageImplementationState => {\n  if (!isERSCMember(page, 'Page')) {\n    throw new TypeError('Page must be created with ERSC.Page.make.');\n  }\n  return page[ERSCStateTypeId];\n};\n\ntype StaticPageOptions<Error, Services> = {\n  readonly params?: never;\n  readonly render: () => Effect.Effect<Awaited<ReactNode>, Error, Services>;\n};\ntype ParameterizedPageOptions<ParamsSchema extends PageParamsSchema<Services>, Error, Services> = {\n  readonly params: ParamsSchema;\n  readonly render: (props: {\n    readonly params: ParamsSchema['Type'];\n  }) => Effect.Effect<Awaited<ReactNode>, Error, Services>;\n};\n\nexport type PageFactory<ApplicationServices, AvailableServices> = {\n  readonly make: {\n    <ParamsSchema extends PageParamsSchema<AvailableServices>, Error>(\n      options: ParameterizedPageOptions<ParamsSchema, Error, AvailableServices> &\n        ValidPageParamsSchema<ParamsSchema>,\n    ): ParameterizedPageDefinition<ApplicationServices, PageParamKeys<ParamsSchema>>;\n    <Error>(\n      options: StaticPageOptions<Error, AvailableServices>,\n    ): StaticPageDefinition<ApplicationServices>;\n  };\n};\n\nexport const makePageFactory = <ApplicationServices, AvailableServices>(\n  identity: ERSCIdentity<ApplicationServices>,\n  middleware: ReadonlyArray<AnyMiddleware<ApplicationServices>>,\n): PageFactory<ApplicationServices, AvailableServices> => {\n  function make<ParamsSchema extends PageParamsSchema<AvailableServices>, Error>(\n    options: ParameterizedPageOptions<ParamsSchema, Error, AvailableServices> &\n      ValidPageParamsSchema<ParamsSchema>,\n  ): ParameterizedPageDefinition<ApplicationServices, PageParamKeys<ParamsSchema>>;\n  function make<Error>(\n    options: StaticPageOptions<Error, AvailableServices>,\n  ): StaticPageDefinition<ApplicationServices>;\n  function make<Error>(\n    options:\n      | Omit<StaticPageOptions<Error, AvailableServices>, 'params'>\n      | ParameterizedPageOptions<PageParamsSchema<AvailableServices>, Error, AvailableServices>,\n  ): AnyPageDefinition<ApplicationServices> {\n    if ('params' in options) {\n      const { params: paramsSchema, render } = options;\n      const decodeParams = Schema.decodeUnknownEffect(paramsSchema);\n      const component: PageComponent = ({ params }) =>\n        identity.renderRuntime.run(\n          'Page',\n          decodeParams(params).pipe(\n            Effect.flatMap((decodedParams) =>\n              Effect.suspend(() => render({ params: decodedParams })),\n            ),\n          ),\n          middleware,\n        );\n      return new PageDefinitionImpl<\n        ApplicationServices,\n        PageParamKeys<typeof paramsSchema>,\n        'Parameterized',\n        typeof paramsSchema\n      >(identity, component, paramsSchema);\n    }\n\n    const { render } = options;\n    const component: PageComponent = () =>\n      identity.renderRuntime.run('Page', Effect.suspend(render), middleware);\n    return new PageDefinitionImpl<ApplicationServices, never, 'Static', null>(\n      identity,\n      component,\n      null,\n    );\n  }\n\n  return { make };\n};\n"],"names":["Effect","Schema","ERSCIdentityTypeId","isERSCMember","ERSCMemberKindTypeId","ERSCStateTypeId","PageDefinitionImpl","identity","component","paramsSchema","Object","getPageState","page","TypeError","makePageFactory","middleware","make","options","render","decodeParams","params","decodedParams"],"mappings":";;;;;AAAoD;AAU3B;AAoFzB,MAAMM,kBAAkBA;IAcb,CAACJ,kBAAkBA,CAAC,CAAyB;IAC7C,CAACE,oBAAoBA,CAAC,GAAG,OAAgB;IAClD,IAAI,CAACC,eAAeA,CAAC,GAA4B;QAC/C,OAAO,IAAI;IACb;IACS,UAAyB;IACzB,aAA2B;IAEpC,YACEE,QAAgC,EAChCC,SAAwB,EACxBC,YAA0B,CAC1B;QACA,IAAI,CAACP,kBAAkBA,CAAC,GAAGK;QAC3B,IAAI,CAAC,SAAS,GAAGC;QACjB,IAAI,CAAC,YAAY,GAAGC;QACpBC,OAAO,MAAM,CAAC,IAAI;IACpB;AACF;AAEO,MAAMC,YAAYA,GAAG,CAC1BC;IAEA,IAAI,CAACT,YAAYA,CAACS,MAAM,SAAS;QAC/B,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOD,IAAI,CAACP,eAAeA,CAAC;AAC9B,EAAE;AAyBK,MAAMS,eAAeA,GAAG,CAC7BP,UACAQ;IASA,SAASC,KACPC,OAE2F;QAE3F,IAAI,YAAYA,SAAS;YACvB,MAAM,EAAE,QAAQR,YAAY,EAAES,MAAM,EAAE,GAAGD;YACzC,MAAME,eAAelB,0BAA0B,CAACQ;YAChD,MAAMD,YAA2B,CAAC,EAAEY,MAAM,EAAE,GAC1Cb,SAAS,aAAa,CAAC,GAAG,CACxB,QACAY,aAAaC,QAAQ,IAAI,CACvBpB,cAAc,CAAC,CAACqB,gBACdrB,cAAc,CAAC,IAAMkB,OAAO;4BAAE,QAAQG;wBAAc,OAGxDN;YAEJ,OAAO,IAAIT,kBAAkBA,CAK3BC,UAAUC,WAAWC;QACzB;QAEA,MAAM,EAAES,MAAM,EAAE,GAAGD;QACnB,MAAMT,YAA2B,IAC/BD,SAAS,aAAa,CAAC,GAAG,CAAC,QAAQP,cAAc,CAACkB,SAASH;QAC7D,OAAO,IAAIT,kBAAkBA,CAC3BC,UACAC,WACA;IAEJ;IAEA,OAAO;QAAEQ;IAAK;AAChB,EAAE"}