@compean/core 0.1.1 → 0.1.2

package/dist/changed.d.ts

@@ -8,3 +8,4 @@ export interface DependsOnMeta<R extends string = string> {
  * refresh. A writer calls this after a change and never needs to know who reads.
  */
 export declare function changed<R extends string>(cache: Pick<QueryClient, 'invalidateQueries'>, resource: R): Promise<void>;
+//# sourceMappingURL=changed.d.ts.map

package/dist/changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed.d.ts","sourceRoot":"","sources":["../src/changed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,wEAAwE;AACxE,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACpD,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,mBAAmB,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAInH"}

package/dist/controller.d.ts

@@ -55,3 +55,4 @@ export declare abstract class Controller<TState> extends Observable {
     private describeAndReport;
     private settle;
 }
+//# sourceMappingURL=controller.d.ts.map

package/dist/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../src/controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAM7C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAI7D;;;;;GAKG;AACH,8BAAsB,UAAU,CAAC,MAAM,CAAE,SAAQ,UAAU;IACvD,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,aAAa,CAA+B;IACpD,oEAAoE;IACpE,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,wGAAwG;IACxG,OAAO,CAAC,iBAAiB,CAAK;IAC9B,uGAAuG;IACvG,OAAO,CAAC,gBAAgB,CAAuB;IAE/C,yGAAyG;IACzG,aAAoB,KAAK,IAAI,MAAM,CAAC;IAEpC;;;OAGG;IACI,UAAU,IAAI,IAAI,CAAG;IAE5B;;;OAGG;IACI,KAAK,IAAI,IAAI,CAKnB;IAED,0EAA0E;IACnE,OAAO,IAAI,IAAI,CAIrB;IAED,SAAS,KAAK,MAAM,IAAI,gBAAgB,CAEvC;IAED,6FAA6F;IAC7F,SAAS,KAAK,SAAS,IAAI,MAAM,GAAG,IAAI,CAEvC;IAED,uFAAuF;IACvF,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAEzC;IAED;;;;;OAKG;IACH,UAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB7D;IAED;;;OAGG;IACH,UAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5D;IAED,0FAA0F;IAC1F,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,MAAM;CAKjB"}

package/dist/eslint/index.d.ts

@@ -4,3 +4,4 @@ import type { Linter } from 'eslint';
  * parser setup: `export default [...typescriptConfig, ...compeanRules()]`.
  */
 export declare function compeanRules(): Linter.Config[];
+//# sourceMappingURL=index.d.ts.map

package/dist/eslint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/eslint/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,MAAM,EAAQ,MAAM,QAAQ,CAAC;AAwJnD;;;GAGG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,CAuB9C"}

package/dist/form.d.ts

@@ -41,3 +41,4 @@ export declare class Form<S extends z.ZodObject> extends Observable {
     private validate;
 }
 export {};
+//# sourceMappingURL=form.d.ts.map

package/dist/form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.d.ts","sourceRoot":"","sources":["../src/form.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,KAAK,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvD,MAAM,WAAW,QAAQ,CAAC,CAAC;IACvB,MAAM,EAAE,CAAC,CAAC;IACV,6EAA6E;IAC7E,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACvB,4FAA4F;IAC5F,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oDAAoD;IACpD,SAAS,EAAE,OAAO,CAAC;CACtB;AAQD;;;GAGG;AACH,qBAAa,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAE,SAAQ,UAAU;IAQnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR5B,OAAO,CAAC,MAAM,CAAa;IAC3B,qGAAqG;IACrG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,iGAAiG;IACjG,OAAO,CAAC,aAAa,CAAS;IAE9B,YACqB,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAIvC;IAED,uFAAuF;IAChF,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAG3E;IAED,+EAA+E;IACxE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAG1C;IAED,2DAA2D;IACpD,KAAK,IAAI,IAAI,CAKnB;IAED,qGAAqG;IAC9F,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAelC;IAED;;;;;OAKG;IACU,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhF;IAED,OAAO,CAAC,QAAQ;CAgBnB"}

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export { Controller, type ControllerStatus } from './controller.js';
 export { Form, type FormView } from './form.js';
 export { readJson, type JsonResponse } from './read-json.js';
 export { changed, type DependsOnMeta } from './changed.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAE,YAAY,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/observable.d.ts

@@ -6,3 +6,4 @@ export declare abstract class Observable {
     /** Calls every listener synchronously, in subscription order. Listeners added during a call wait for the next one. */
     protected notify(): void;
 }
+//# sourceMappingURL=observable.d.ts.map

package/dist/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../src/observable.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,8BAAsB,UAAU;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IAEnD,gFAAgF;IACzE,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKjD;IAED,sHAAsH;IACtH,SAAS,CAAC,MAAM,IAAI,IAAI,CAIvB;CACJ"}

package/dist/prettier/index.d.ts

@@ -5,3 +5,4 @@ import type { Config } from 'prettier';
  */
 declare const config: Config;
 export default config;
+//# sourceMappingURL=index.d.ts.map

package/dist/prettier/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prettier/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,QAAA,MAAM,MAAM,EAAE,MASb,CAAC;eAEa,MAAM"}

package/dist/react/index.d.ts

@@ -22,3 +22,4 @@ export declare function Toaster({ children, duration }: {
     duration?: number;
 }): ReactNode;
 export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAgB,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE/D,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAoB5D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,EACvD,MAAM,EAAE,MAAM,CAAC,EACf,GAAG,CAAC,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,UAAU,EAAE,CAAC,CAAA;CAAE,CAgCtC;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,EAAE,QAAQ,EAAE,QAAe,EAAE,EAAE;IAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAc9H"}

package/dist/read-json.d.ts

@@ -11,3 +11,4 @@ export interface JsonResponse<T> {
  * @throws Error for any other failure, which `load()` and `run()` treat as a bug.
  */
 export declare function readJson<T>(request: Promise<JsonResponse<T>> | JsonResponse<T>): Promise<T>;
+//# sourceMappingURL=read-json.d.ts.map

package/dist/read-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-json.d.ts","sourceRoot":"","sources":["../src/read-json.ts"],"names":[],"mappings":"AAEA,gEAAgE;AAChE,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACtB;AAKD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAajG"}

package/dist/registry.d.ts

@@ -17,3 +17,4 @@ export declare function $S<T>(token: Token<T>): T;
 /** Forgets every registered service. Tests call it before each test. */
 export declare function resetServices(): void;
 export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAGA,KAAK,KAAK,CAAC,CAAC,IAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAarD,wGAAwG;AACxG,KAAK,WAAW,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAEpF;AAED;;;;GAIG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CASxC;AAED,wEAAwE;AACxE,wBAAgB,aAAa,IAAI,IAAI,CAEpC"}

package/dist/report-safely.d.ts

@@ -1,3 +1,4 @@
 import { type ReportContext } from './reporting.js';
 /** Reports through the registered reporter, falling back to the console if that reporter fails. */
 export declare function reportSafely(error: unknown, context: ReportContext): void;
+//# sourceMappingURL=report-safely.d.ts.map

package/dist/report-safely.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-safely.d.ts","sourceRoot":"","sources":["../src/report-safely.ts"],"names":[],"mappings":"AACA,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpF,mGAAmG;AACnG,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAQzE"}

package/dist/reporting.d.ts

@@ -15,3 +15,4 @@ export declare abstract class ErrorReporter {
 export declare class ConsoleReporter implements ErrorReporter {
     report(error: unknown, context: ReportContext): void;
 }
+//# sourceMappingURL=reporting.d.ts.map

package/dist/reporting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../src/reporting.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC1B,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,8BAAsB,aAAa;IAC/B,mGAAmG;IACnG,SAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CACxE;AAED,qBAAa,eAAgB,YAAW,aAAa;IAC1C,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAM1D;CACJ"}

package/dist/server/index.d.ts

@@ -20,3 +20,4 @@ export declare function validator<Target extends keyof ValidationTargets, Schema
  * @throws Error naming every missing or invalid variable, so a bad deploy stops at startup.
  */
 export declare function loadConfig<Schema extends z.ZodObject>(schema: Schema, env?: Record<string, string | undefined>): z.output<Schema>;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAG5D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,YAAY,CAiB3C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,iBAAiB,EAAE,MAAM,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;UAMzH;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACjD,MAAM,EAAE,MAAM,EACd,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACtD,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAOlB"}

package/dist/testing/index.d.ts

@@ -13,3 +13,4 @@ export type Recorded<T> = T & {
 };
 /** A navigation object for controller tests: every method exists and records its calls. */
 export declare function recordingNavigation<T extends object>(): Recorded<T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,gEAAgE;AAChE,qBAAa,iBAAkB,YAAW,aAAa;IACnD,SAAgB,OAAO,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAE,CAAC,CAAM;IAEzE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAE1D;CACJ;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,CAAA;CAAE,CAAC;AAEhF,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAgBnE"}

package/dist/toast.service.d.ts

@@ -18,3 +18,4 @@ export declare class ToastService extends Observable {
     /** Hides the toast with this id; a newer toast stays. */
     dismiss(id: number): void;
 }
+//# sourceMappingURL=toast.service.d.ts.map

package/dist/toast.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.service.d.ts","sourceRoot":"","sources":["../src/toast.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5C,MAAM,WAAW,KAAK;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;CACnB;AAED,gHAAgH;AAChH,qBAAa,YAAa,SAAQ,UAAU;IACxC,sDAAsD;IACtD,OAAO,CAAC,OAAO,CAAsB;IACrC,mFAAmF;IACnF,OAAO,CAAC,MAAM,CAAK;IAEnB,2HAA2H;IACpH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,SAAqB,GAAG,IAAI,CAG9D;IAED,0DAA0D;IACnD,MAAM,IAAI,KAAK,GAAG,IAAI,CAE5B;IAED,yDAAyD;IAClD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAM/B;CACJ"}

package/dist/user-error.d.ts

@@ -7,3 +7,4 @@ export declare class UserError extends Error {
     readonly status: UserErrorStatus;
     constructor(message: string, status?: UserErrorStatus);
 }
+//# sourceMappingURL=user-error.d.ts.map

package/dist/user-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-error.d.ts","sourceRoot":"","sources":["../src/user-error.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE1D;;;GAGG;AACH,qBAAa,SAAU,SAAQ,KAAK;aAGZ,MAAM,EAAE,eAAe;IAF3C,YACI,OAAO,EAAE,MAAM,EACC,MAAM,GAAE,eAAqB,EAIhD;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@compean/core",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "description": "Shared core for Compean apps: controllers, services, errors, forms and the framework rules.",
     "license": "MIT",
     "type": "module",
@@ -14,6 +14,9 @@
     },
     "files": [
         "dist",
+        "src",
+        "!src/**/*.test.ts",
+        "!src/**/*.test.tsx",
         "RULES.md"
     ],
     "exports": {

package/src/changed.ts

@@ -0,0 +1,16 @@
+import type { QueryClient } from '@tanstack/query-core';
+
+/** Query metadata naming the resources a cached query is built from. */
+export interface DependsOnMeta<R extends string = string> {
+    dependsOn?: readonly R[];
+}
+
+/**
+ * Marks stale every cached query whose `meta.dependsOn` lists `resource`, so screens showing it
+ * refresh. A writer calls this after a change and never needs to know who reads.
+ */
+export function changed<R extends string>(cache: Pick<QueryClient, 'invalidateQueries'>, resource: R): Promise<void> {
+    return cache.invalidateQueries({
+        predicate: (query) => (query.meta as DependsOnMeta | undefined)?.dependsOn?.includes(resource) ?? false,
+    });
+}

package/src/controller.ts

@@ -0,0 +1,128 @@
+import { Observable } from './observable.js';
+import { $S } from './registry.js';
+import { reportSafely } from './report-safely.js';
+import { ToastService } from './toast.service.js';
+import { UserError } from './user-error.js';
+
+/**
+ * What the screen shows as a whole: a loading view, the content, or a full-screen error with retry.
+ * See "Controller status" in the README's design notes.
+ */
+export type ControllerStatus = 'loading' | 'ready' | 'error';
+
+const GENERIC_MESSAGE = 'Something went wrong. Try again.';
+
+/**
+ * One screen's logic and state. `state` is what the screen renders; actions are public methods.
+ * A controller runs unchanged on web and mobile, so it never imports React, React Native or a
+ * router. Subclasses override `initialize()` and `state`, load data with `load()` and perform
+ * actions with `run()`; neither needs a try/catch.
+ */
+export abstract class Controller<TState> extends Observable {
+    /** Undone on `dispose()` in reverse order, so the last thing tracked is undone first. */
+    private readonly cleanups: Array<() => void> = [];
+    private currentStatus: ControllerStatus = 'loading';
+    /** The message for the 'error' status; null in any other status. */
+    private currentLoadError: string | null = null;
+    /** Loads started before the screen was first ready and not yet finished. The status settles at zero. */
+    private pendingFirstLoads = 0;
+    /** The first failure among the pending first loads; it becomes the load error once they all finish. */
+    private firstLoadFailure: string | null = null;
+
+    /** Read by the screen after every `notify()`. Build it from fields; never fetch or do slow work here. */
+    public abstract get state(): TState;
+
+    /**
+     * Subclass hook, called once by `start()` when the screen mounts. Start loading with `load()`
+     * and subscribe to services here, registering each unsubscribe with `track()`.
+     */
+    public initialize(): void {}
+
+    /**
+     * Mounts the controller: calls `initialize()`, then marks a screen that started no load as
+     * ready. `useController` calls this; tests call it in place of mounting a screen.
+     */
+    public start(): void {
+        this.initialize();
+        if (this.pendingFirstLoads === 0 && this.currentStatus === 'loading') {
+            this.settle('ready', null);
+        }
+    }
+
+    /** Safe to call more than once: each cleanup runs only the first time. */
+    public dispose(): void {
+        for (const cleanup of this.cleanups.splice(0).reverse()) {
+            cleanup();
+        }
+    }
+
+    protected get status(): ControllerStatus {
+        return this.currentStatus;
+    }
+
+    /** The message to show when status is 'error': a UserError's own words, or a generic one. */
+    protected get loadError(): string | null {
+        return this.currentLoadError;
+    }
+
+    /** Runs `cleanup` (an unsubscribe, a clearTimeout) when the controller is disposed. */
+    protected track(cleanup: () => void): void {
+        this.cleanups.push(cleanup);
+    }
+
+    /**
+     * Loads the screen's data. Before the screen is first ready, the status settles once every
+     * load started so far has finished: 'ready' if all succeeded, otherwise 'error' with the first
+     * failure's message (shown full screen; retry by calling `load()` again). Once ready, a load is
+     * a refresh: the data stays on screen and a failure shows as a toast. Never rejects.
+     */
+    protected async load(task: () => Promise<void>): Promise<void> {
+        if (this.currentStatus === 'ready') {
+            await this.run(task);
+            return;
+        }
+        if (this.currentStatus === 'error') {
+            this.settle('loading', null);
+        }
+        this.pendingFirstLoads += 1;
+        try {
+            await task();
+        } catch (error) {
+            this.firstLoadFailure ??= this.describeAndReport(error);
+        } finally {
+            this.pendingFirstLoads -= 1;
+            if (this.pendingFirstLoads === 0) {
+                const failure = this.firstLoadFailure;
+                this.firstLoadFailure = null;
+                this.settle(failure ? 'error' : 'ready', failure);
+            }
+        }
+    }
+
+    /**
+     * Performs an action. It never changes the screen's status: a failure shows as an error toast,
+     * with a UserError's own message or a generic one, and bugs are reported. Never rejects.
+     */
+    protected async run(task: () => Promise<void>): Promise<void> {
+        try {
+            await task();
+        } catch (error) {
+            $S(ToastService).show(this.describeAndReport(error), 'error');
+        }
+    }
+
+    /** The message the user sees for this error; reports it first unless it's a UserError. */
+    private describeAndReport(error: unknown): string {
+        if (error instanceof UserError) {
+            return error.message;
+        }
+        reportSafely(error, { where: this.constructor.name });
+        return GENERIC_MESSAGE;
+    }
+
+    private settle(status: ControllerStatus, loadError: string | null): void {
+        this.currentStatus = status;
+        this.currentLoadError = loadError;
+        this.notify();
+    }
+}

package/src/eslint/index.ts

@@ -0,0 +1,180 @@
+import type { ESLint, Linter, Rule } from 'eslint';
+
+type ImportNode = { source?: { value?: unknown } | null };
+
+/** Packages that only run on one platform: React, React Native, Expo and the routers. */
+const PLATFORM_IMPORT =
+    /^(react|react-dom|react-native|react-router|expo)(\/|$)|^react-native-|^react-router-|^@tanstack\/react-|^expo-|^@expo\/|^@react-navigation\//;
+/** What packages/domain may import: its own files and zod. */
+const DOMAIN_ALLOWED = /^(\.{1,2}\/|zod(\/|$))/;
+/** Tests may import their runner and test libraries, which the platform and purity rules would flag. */
+const TEST_FILES = ['**/*.test.{ts,tsx}'];
+
+/** TanStack Router calls whose options object defines a route. */
+const ROUTE_FACTORIES = new Set([
+    'createFileRoute',
+    'createRoute',
+    'createRootRoute',
+    'createRootRouteWithContext',
+    'createLazyFileRoute',
+]);
+
+/** Which files may import a library that must stay hidden behind one kind of module. */
+const LIBRARY_OWNERS: ReadonlyArray<{ library: RegExp; owner: RegExp; ownerName: string }> = [
+    {
+        library: /^@tanstack\/(query-core|react-query)(\/|$)/,
+        owner: /(\.service|(^|[\\/])boot)\.tsx?$/,
+        ownerName: 'a client service (*.service.ts) or boot.ts',
+    },
+    { library: /^better-auth(\/|$)/, owner: /(^|[\\/])auth\.service\.tsx?$/, ownerName: 'the auth service (auth.service.ts)' },
+];
+
+function importSource(node: ImportNode): string | null {
+    const value = node.source?.value;
+    return typeof value === 'string' ? value : null;
+}
+
+function propertyName(key: Rule.Node | { type: string; name?: string; value?: unknown }): unknown {
+    if (key.type === 'Identifier') {
+        return (key as { name: string }).name;
+    }
+    if (key.type === 'Literal') {
+        return (key as { value: unknown }).value;
+    }
+    return null;
+}
+
+function calleeName(callee: { type: string; name?: string; callee?: unknown }): string | null {
+    if (callee.type === 'Identifier') {
+        return callee.name ?? null;
+    }
+    if (callee.type === 'CallExpression') {
+        return calleeName(callee.callee as { type: string; name?: string; callee?: unknown });
+    }
+    return null;
+}
+
+/** True for the options object of `createFileRoute('/path')({...})`, `createRoute({...})` and similar. */
+function isRouteDefinition(object: Rule.Node | undefined): boolean {
+    const call = object?.parent;
+    if (object?.type !== 'ObjectExpression' || call?.type !== 'CallExpression') {
+        return false;
+    }
+    const name = calleeName(call.callee as { type: string; name?: string; callee?: unknown });
+    return name !== null && ROUTE_FACTORIES.has(name);
+}
+
+function onImports(check: (node: Rule.Node, source: string) => void): Rule.RuleListener {
+    const visit = (node: Rule.Node) => {
+        const source = importSource(node as unknown as ImportNode);
+        if (source) {
+            check(node, source);
+        }
+    };
+    return { ImportDeclaration: visit, ExportNamedDeclaration: visit, ExportAllDeclaration: visit, ImportExpression: visit };
+}
+
+const platformFree: Rule.RuleModule = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'Shared client code and controllers run on web and mobile, so they import no platform or router.' },
+        messages: {
+            platform:
+                "'{{source}}' is platform code. Controllers and packages/client stay platform-free; use it in a screen or an adapter.",
+        },
+        schema: [],
+    },
+    create: (context) =>
+        onImports((node, source) => {
+            if (PLATFORM_IMPORT.test(source)) {
+                context.report({ node, messageId: 'platform', data: { source } });
+            }
+        }),
+};
+
+const domainPure: Rule.RuleModule = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'packages/domain is shared by client and server, so it imports only itself and Zod.' },
+        messages: { impure: "packages/domain may import only its own files and zod, not '{{source}}'." },
+        schema: [],
+    },
+    create: (context) =>
+        onImports((node, source) => {
+            if (!DOMAIN_ALLOWED.test(source)) {
+                context.report({ node, messageId: 'impure', data: { source } });
+            }
+        }),
+};
+
+const noRouteLoaders: Rule.RuleModule = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'Controllers load data; route files only pick a screen.' },
+        messages: { loader: "Routes never use loaders. Load data in the screen's controller through a service." },
+        schema: [],
+    },
+    create: (context) => ({
+        Property(node) {
+            if (!node.computed && propertyName(node.key) === 'loader' && isRouteDefinition(node.parent)) {
+                context.report({ node, messageId: 'loader' });
+            }
+        },
+    }),
+};
+
+const libraryOwners: Rule.RuleModule = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'Libraries hidden behind one kind of module stay there.' },
+        messages: { owner: "Only {{ownerName}} may import '{{source}}'." },
+        schema: [],
+    },
+    create: (context) =>
+        onImports((node, source) => {
+            for (const { library, owner, ownerName } of LIBRARY_OWNERS) {
+                if (library.test(source) && !owner.test(context.filename)) {
+                    context.report({ node, messageId: 'owner', data: { source, ownerName } });
+                }
+            }
+        }),
+};
+
+const plugin: ESLint.Plugin = {
+    meta: { name: '@compean/core/eslint' },
+    rules: {
+        'platform-free': platformFree,
+        'domain-pure': domainPure,
+        'no-route-loaders': noRouteLoaders,
+        'library-owners': libraryOwners,
+    },
+};
+
+/**
+ * The framework rules a tool can check, as an ESLint flat config. Add it after your TypeScript
+ * parser setup: `export default [...typescriptConfig, ...compeanRules()]`.
+ */
+export function compeanRules(): Linter.Config[] {
+    return [
+        { plugins: { compean: plugin } },
+        {
+            files: ['packages/client/**/*.{ts,tsx}', '**/*.controller.{ts,tsx}'],
+            ignores: TEST_FILES,
+            rules: { 'compean/platform-free': 'error' },
+        },
+        {
+            files: ['packages/domain/**/*.{ts,tsx}'],
+            ignores: TEST_FILES,
+            rules: { 'compean/domain-pure': 'error' },
+        },
+        {
+            files: ['apps/web/routes/**/*.{ts,tsx}'],
+            rules: { 'compean/no-route-loaders': 'error' },
+        },
+        {
+            files: ['packages/client/**/*.{ts,tsx}', 'apps/web/**/*.{ts,tsx}', 'apps/mobile/**/*.{ts,tsx}'],
+            ignores: TEST_FILES,
+            rules: { 'compean/library-owners': 'error' },
+        },
+    ];
+}

package/src/form.ts

@@ -0,0 +1,114 @@
+import type { z } from 'zod';
+import { Observable } from './observable.js';
+
+type FieldErrors<V> = Partial<Record<keyof V, string>>;
+
+export interface FormView<V> {
+    values: V;
+    /** Errors for fields the user has touched, or all of them after a submit. */
+    errors: FieldErrors<V>;
+    /** An error that belongs to the whole form (a rule across fields), shown after a submit. */
+    formError: string | null;
+    /** True when the current values pass the schema. */
+    canSubmit: boolean;
+}
+
+interface Validation<V> {
+    valid: boolean;
+    fieldErrors: FieldErrors<V>;
+    formError: string | null;
+}
+
+/**
+ * A form's values and errors, checked by a domain schema. A controller holds one as
+ * `public readonly`, the screen binds inputs to it, and `submit()` runs only valid input.
+ */
+export class Form<S extends z.ZodObject> extends Observable {
+    private values: z.input<S>;
+    /** Fields allowed to show their error: visited by the user, or every field after a failed submit. */
+    private readonly touched = new Set<keyof z.input<S>>();
+    /** Set by a failed submit: form-level errors belong to no field, so no touch can reveal them. */
+    private showFormError = false;
+
+    public constructor(
+        private readonly schema: S,
+        private readonly initial: z.input<S>,
+    ) {
+        super();
+        this.values = { ...initial };
+    }
+
+    /** If the field was touched, its visible error is re-checked against the new value. */
+    public set<K extends keyof z.input<S>>(field: K, value: z.input<S>[K]): void {
+        this.values = { ...this.values, [field]: value };
+        this.notify();
+    }
+
+    /** Marks a field as visited (usually on blur), so its error starts showing. */
+    public touch(field: keyof z.input<S>): void {
+        this.touched.add(field);
+        this.notify();
+    }
+
+    /** Back to the initial values, with every error hidden. */
+    public reset(): void {
+        this.values = { ...this.initial };
+        this.touched.clear();
+        this.showFormError = false;
+        this.notify();
+    }
+
+    /** A snapshot for the screen: a copy of the values, the visible errors and whether it can submit. */
+    public view(): FormView<z.input<S>> {
+        const validation = this.validate();
+        const errors: FieldErrors<z.input<S>> = {};
+        for (const field of this.touched) {
+            const message = validation.fieldErrors[field];
+            if (message) {
+                errors[field] = message;
+            }
+        }
+        return {
+            values: { ...this.values },
+            errors,
+            formError: this.showFormError ? validation.formError : null,
+            canSubmit: validation.valid,
+        };
+    }
+
+    /**
+     * Runs `action` with the parsed input when it's valid; otherwise shows every error and skips
+     * it. The values stay as they are either way; clear them with `reset()` inside `action`.
+     *
+     * @throws whatever `action` throws, so the surrounding `run()` reports it.
+     */
+    public async submit(action: (input: z.output<S>) => Promise<void>): Promise<void> {
+        const result = this.schema.safeParse(this.values);
+        if (!result.success) {
+            this.showFormError = true;
+            for (const field of Object.keys(this.schema.shape) as Array<keyof z.input<S>>) {
+                this.touched.add(field);
+            }
+            this.notify();
+            return;
+        }
+        await action(result.data);
+    }
+
+    private validate(): Validation<z.input<S>> {
+        const result = this.schema.safeParse(this.values);
+        const validation: Validation<z.input<S>> = { valid: result.success, fieldErrors: {}, formError: null };
+        if (result.success) {
+            return validation;
+        }
+        for (const issue of result.error.issues) {
+            const field = issue.path[0] as keyof z.input<S> | undefined;
+            if (field === undefined) {
+                validation.formError ??= issue.message;
+            } else if (!validation.fieldErrors[field]) {
+                validation.fieldErrors[field] = issue.message;
+            }
+        }
+        return validation;
+    }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export { Observable } from './observable.js';
+export { $S, register } from './registry.js';
+export { UserError, type UserErrorStatus } from './user-error.js';
+export { ErrorReporter, ConsoleReporter, type ReportContext } from './reporting.js';
+export { ToastService, type Toast, type ToastTone } from './toast.service.js';
+export { Controller, type ControllerStatus } from './controller.js';
+export { Form, type FormView } from './form.js';
+export { readJson, type JsonResponse } from './read-json.js';
+export { changed, type DependsOnMeta } from './changed.js';

package/src/observable.ts

@@ -0,0 +1,19 @@
+/** Something screens can watch: subscribers are called after every change. */
+export abstract class Observable {
+    private readonly listeners = new Set<() => void>();
+
+    /** Calls `listener` after each change until the returned function is called. */
+    public subscribe(listener: () => void): () => void {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+
+    /** Calls every listener synchronously, in subscription order. Listeners added during a call wait for the next one. */
+    protected notify(): void {
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+}

package/src/prettier/index.ts

@@ -0,0 +1,18 @@
+import type { Config } from 'prettier';
+
+/**
+ * The formatting every Compean project shares. Point to it from package.json with
+ * `"prettier": "@compean/core/prettier"` instead of copying it.
+ */
+const config: Config = {
+    printWidth: 130,
+    tabWidth: 4,
+    useTabs: false,
+    singleQuote: true,
+    jsxSingleQuote: true,
+    semi: true,
+    trailingComma: 'all',
+    bracketSpacing: true,
+};
+
+export default config;

package/src/react/index.tsx

@@ -0,0 +1,88 @@
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore, type ReactNode } from 'react';
+import type { Controller } from '../controller.js';
+import { $S } from '../registry.js';
+import { ToastService, type Toast } from '../toast.service.js';
+
+type StateOf<C> = C extends Controller<infer S> ? S : never;
+
+/** The controller this hook rendered, the key it was created for, and its latest state. */
+interface Mounted<C> {
+    controller: C;
+    key: string | undefined;
+    state: StateOf<C>;
+}
+
+/**
+ * Controllers this hook has disposed. React StrictMode re-runs effects on the same instance after
+ * disposing it; the hook mounts a fresh controller instead of starting a disposed one.
+ */
+const disposed = new WeakSet<Controller<unknown>>();
+
+function mount<C extends Controller<unknown>>(create: () => C, key: string | undefined): Mounted<C> {
+    const controller = create();
+    return { controller, key, state: controller.state as StateOf<C> };
+}
+
+/**
+ * Creates a screen's controller, initializes it, re-renders on every `notify()` and disposes it on
+ * unmount. A new `key` (such as a route param) replaces the controller. A controller is never
+ * initialized again after it was disposed, so React StrictMode gets a fresh one instead.
+ * `create` runs during render and may run more than once, so a constructor must not subscribe
+ * or start work; do that in `initialize()`.
+ */
+export function useController<C extends Controller<unknown>>(
+    create: () => C,
+    key?: string,
+): { state: StateOf<C>; controller: C } {
+    const createRef = useRef(create);
+    createRef.current = create;
+    const [mounted, setMounted] = useState(() => mount(create, key));
+
+    let current = mounted;
+    if (mounted.key !== key) {
+        current = mount(create, key);
+        setMounted(current);
+    }
+    const { controller } = current;
+
+    useEffect(() => {
+        if (disposed.has(controller)) {
+            setMounted((previous) => (previous.controller === controller ? mount(createRef.current, previous.key) : previous));
+            return;
+        }
+        const refresh = () =>
+            setMounted((previous) =>
+                previous.controller === controller ? { ...previous, state: controller.state as StateOf<C> } : previous,
+            );
+        const unsubscribe = controller.subscribe(refresh);
+        refresh();
+        controller.start();
+        return () => {
+            unsubscribe();
+            disposed.add(controller);
+            controller.dispose();
+        };
+    }, [controller]);
+
+    return { state: current.state, controller };
+}
+
+/**
+ * Shows the latest toast from ToastService, rendered by the app's own `children`, and hides it
+ * after `duration` milliseconds. Mount it once at the app root.
+ */
+export function Toaster({ children, duration = 4000 }: { children: (toast: Toast) => ReactNode; duration?: number }): ReactNode {
+    const toasts = $S(ToastService);
+    const subscribe = useCallback((onChange: () => void) => toasts.subscribe(onChange), [toasts]);
+    const toast = useSyncExternalStore(subscribe, () => toasts.latest());
+
+    useEffect(() => {
+        if (!toast) {
+            return;
+        }
+        const timer = setTimeout(() => toasts.dismiss(toast.id), duration);
+        return () => clearTimeout(timer);
+    }, [toast, toasts, duration]);
+
+    return toast ? children(toast) : null;
+}

package/src/read-json.ts

@@ -0,0 +1,32 @@
+import { UserError, type UserErrorStatus } from './user-error.js';
+
+/** The part of a fetch or hc response that `readJson` needs. */
+export interface JsonResponse<T> {
+    ok: boolean;
+    status: number;
+    json(): Promise<T>;
+}
+
+/** Statuses a UserError can carry; any other 4xx is shown as a 400. */
+const KNOWN_STATUSES: ReadonlySet<number> = new Set<UserErrorStatus>([400, 401, 403, 404, 409]);
+
+/**
+ * The body of a successful response; undefined for 204 No Content.
+ *
+ * @throws UserError for a 4xx carrying `{ message }`, so `load()` and `run()` show its words.
+ * @throws Error for any other failure, which `load()` and `run()` treat as a bug.
+ */
+export async function readJson<T>(request: Promise<JsonResponse<T>> | JsonResponse<T>): Promise<T> {
+    const response = await request;
+    if (response.ok) {
+        return response.status === 204 ? (undefined as T) : response.json();
+    }
+    if (response.status >= 400 && response.status < 500) {
+        const body = (await response.json().catch(() => null)) as { message?: unknown } | null;
+        if (typeof body?.message === 'string') {
+            const status = KNOWN_STATUSES.has(response.status) ? (response.status as UserErrorStatus) : 400;
+            throw new UserError(body.message, status);
+        }
+    }
+    throw new Error(`Request failed with status ${response.status}`);
+}

package/src/registry.ts

@@ -0,0 +1,47 @@
+import { ConsoleReporter, ErrorReporter } from './reporting.js';
+import { ToastService } from './toast.service.js';
+
+type Token<T> = abstract new (...args: never[]) => T;
+
+const services = new Map<Token<unknown>, unknown>();
+
+/**
+ * Framework services that work without wiring, so tests and local runs need no boot code. A
+ * default must be what production wants; apps replace the reporter with a vendor one.
+ */
+const defaults = new Map<Token<unknown>, () => unknown>([
+    [ToastService, () => new ToastService()],
+    [ErrorReporter, () => new ConsoleReporter()],
+]);
+
+/** What callers of `$S(token)` can use: the class's public members, so a test fake needs only those. */
+type PublicShape<T> = { [K in keyof T]: T[K] };
+
+/**
+ * Makes `instance` the one `$S(token)` returns. Called from boot.ts and from tests. The type comes
+ * from the class alone; `instance` must offer its public members, so a fake with extra fields fits.
+ */
+export function register<T>(token: Token<T>, instance: NoInfer<PublicShape<T>>): void {
+    services.set(token, instance);
+}
+
+/**
+ * The service registered for this class, or a framework default (ToastService, ErrorReporter).
+ *
+ * @throws Error when nothing was registered for it: a wiring bug, fixed in boot.ts.
+ */
+export function $S<T>(token: Token<T>): T {
+    if (!services.has(token)) {
+        const create = defaults.get(token);
+        if (!create) {
+            throw new Error(`${token.name} is not registered. Register it in boot.ts.`);
+        }
+        services.set(token, create());
+    }
+    return services.get(token) as T;
+}
+
+/** Forgets every registered service. Tests call it before each test. */
+export function resetServices(): void {
+    services.clear();
+}

package/src/report-safely.ts

@@ -0,0 +1,13 @@
+import { $S } from './registry.js';
+import { ConsoleReporter, ErrorReporter, type ReportContext } from './reporting.js';
+
+/** Reports through the registered reporter, falling back to the console if that reporter fails. */
+export function reportSafely(error: unknown, context: ReportContext): void {
+    try {
+        $S(ErrorReporter).report(error, context);
+    } catch (reporterFailure) {
+        const console = new ConsoleReporter();
+        console.report(error, context);
+        console.report(reporterFailure, { where: 'ErrorReporter' });
+    }
+}

package/src/reporting.ts

@@ -0,0 +1,25 @@
+export interface ReportContext {
+    /** Where it happened: a controller name, or "METHOD /path" on the server. */
+    where: string;
+    userId?: string;
+}
+
+/**
+ * Where bugs go. Register one per app in boot.ts: the console locally and in tests, a vendor
+ * adapter such as Sentry in production. Only `load()`, `run()` and the server's error handler call it,
+ * and they survive a reporter that throws.
+ */
+export abstract class ErrorReporter {
+    /** Records one bug with where it happened. Implementations may throw; callers guard against it. */
+    public abstract report(error: unknown, context: ReportContext): void;
+}
+
+export class ConsoleReporter implements ErrorReporter {
+    public report(error: unknown, context: ReportContext): void {
+        try {
+            console.error(`[${context.where}]`, error);
+        } catch {
+            // Reporting must never break the code that reports.
+        }
+    }
+}

package/src/server/index.ts

@@ -0,0 +1,66 @@
+import { zValidator } from '@hono/zod-validator';
+import type { ErrorHandler, ValidationTargets } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import type { z } from 'zod';
+import { reportSafely } from '../report-safely.js';
+import { UserError } from '../user-error.js';
+
+const GENERIC_MESSAGE = 'Something went wrong';
+
+/**
+ * The app's one error handler: `app.onError(handleErrors())`. A UserError becomes `{ message }`
+ * with its status; an HTTPException below 500 (from Hono middleware) keeps its own response;
+ * anything else is reported and answered with a generic 500.
+ */
+export function handleErrors(): ErrorHandler {
+    return (error, c) => {
+        if (error instanceof UserError) {
+            return c.json({ message: error.message }, error.status);
+        }
+        if (error instanceof HTTPException && error.status < 500) {
+            if (error.res) {
+                return error.getResponse();
+            }
+            return c.json(
+                { message: error.message || 'The request could not be processed' },
+                error.status as ContentfulStatusCode,
+            );
+        }
+        reportSafely(error, { where: `${c.req.method} ${c.req.path}` });
+        return c.json({ message: GENERIC_MESSAGE }, 500);
+    };
+}
+
+/**
+ * zValidator that reports invalid input as a UserError, so it reaches the client through the same
+ * handler and shape as every other user-facing error.
+ */
+export function validator<Target extends keyof ValidationTargets, Schema extends z.ZodType>(target: Target, schema: Schema) {
+    return zValidator(target, schema, (result) => {
+        if (!result.success) {
+            throw new UserError(describeIssues(result.error.issues), 400);
+        }
+    });
+}
+
+/**
+ * The environment, parsed and defaulted by `schema`. Call it first in boot.ts.
+ *
+ * @throws Error naming every missing or invalid variable, so a bad deploy stops at startup.
+ */
+export function loadConfig<Schema extends z.ZodObject>(
+    schema: Schema,
+    env: Record<string, string | undefined> = process.env,
+): z.output<Schema> {
+    const result = schema.safeParse(env);
+    if (!result.success) {
+        const lines = result.error.issues.map((issue) => `- ${issue.path.join('.')}: ${issue.message}`);
+        throw new Error(`Invalid configuration:\n${lines.join('\n')}`);
+    }
+    return result.data;
+}
+
+function describeIssues(issues: readonly z.core.$ZodIssue[]): string {
+    return issues.map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`).join('; ');
+}

package/src/testing/index.ts

@@ -0,0 +1,33 @@
+import { ErrorReporter, type ReportContext } from '../reporting.js';
+
+export { resetServices } from '../registry.js';
+
+/** An ErrorReporter that keeps every report, for assertions. */
+export class RecordingReporter implements ErrorReporter {
+    public readonly reports: Array<{ error: unknown; context: ReportContext }> = [];
+
+    public report(error: unknown, context: ReportContext): void {
+        this.reports.push({ error, context });
+    }
+}
+
+export type Recorded<T> = T & { readonly calls: Array<[string, ...unknown[]]> };
+
+/** A navigation object for controller tests: every method exists and records its calls. */
+export function recordingNavigation<T extends object>(): Recorded<T> {
+    const calls: Array<[string, ...unknown[]]> = [];
+    return new Proxy({ calls } as Recorded<T>, {
+        get(target, property) {
+            if (property === 'calls') {
+                return calls;
+            }
+            // Not a thenable, so awaiting it or returning it from async code doesn't call `then()`.
+            if (property === 'then' || typeof property !== 'string') {
+                return Reflect.get(target, property);
+            }
+            return (...args: unknown[]) => {
+                calls.push([property, ...args]);
+            };
+        },
+    });
+}

package/src/toast.service.ts

@@ -0,0 +1,37 @@
+import { Observable } from './observable.js';
+
+export type ToastTone = 'success' | 'error';
+
+export interface Toast {
+    id: number;
+    message: string;
+    tone: ToastTone;
+}
+
+/** The one channel for short feedback messages. Controllers write the words; `<Toaster />` decides the look. */
+export class ToastService extends Observable {
+    /** The toast on screen; null when none is showing. */
+    private current: Toast | null = null;
+    /** Ids increase, so a late `dismiss` of an older toast never hides a newer one. */
+    private nextId = 1;
+
+    /** Shows `message`, replacing any toast on screen. Use 'error' only outside `load()` and `run()`, which show their own. */
+    public show(message: string, tone: ToastTone = 'success'): void {
+        this.current = { id: this.nextId++, message, tone };
+        this.notify();
+    }
+
+    /** The toast to display, or null when none is showing. */
+    public latest(): Toast | null {
+        return this.current;
+    }
+
+    /** Hides the toast with this id; a newer toast stays. */
+    public dismiss(id: number): void {
+        if (this.current?.id !== id) {
+            return;
+        }
+        this.current = null;
+        this.notify();
+    }
+}

package/src/user-error.ts

@@ -0,0 +1,15 @@
+export type UserErrorStatus = 400 | 401 | 403 | 404 | 409;
+
+/**
+ * An error the user can fix or should be told about. Its message is shown to them word for word,
+ * so write it where the cause is known. Anything that isn't a UserError is treated as a bug.
+ */
+export class UserError extends Error {
+    public constructor(
+        message: string,
+        public readonly status: UserErrorStatus = 400,
+    ) {
+        super(message);
+        this.name = 'UserError';
+    }
+}