@unisian/start 0.0.0-placeholder → 0.0.0-stage

package/README.md

@@ -0,0 +1,3 @@
+# Temporary Holding Version
+
+This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/package.json

@@ -1,53 +1,6 @@
 {
   "name": "@unisian/start",
-  "version": "0.0.0-placeholder",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/baoagency/unisian-next.git",
-    "directory": "packages/start"
-  },
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.mjs",
-    "./react": "./dist/client.mjs",
-    "./serve": "./dist/serve.mjs",
-    "./middleware": "./dist/middleware.mjs",
-    "./function-id": "./dist/function-id.mjs"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@tanstack/react-form": "1.33.5"
-  },
-  "devDependencies": {
-    "@tanstack/react-query": "5.104.1",
-    "@tanstack/react-router": "1.170.41",
-    "@tanstack/react-router-ssr-query": "1.167.3",
-    "@tanstack/react-start": "1.168.60",
-    "effect": "4.0.2",
-    "react": "19.3.0",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
-    "@unisian/capability": "0.1.0",
-    "@unisian/effect-observability": "0.1.0",
-    "@unisian/shopify-auth": "0.1.0",
-    "@unisian/shopify-sessions": "0.1.0"
-  },
-  "peerDependencies": {
-    "@tanstack/react-query": "^5.104.1",
-    "@tanstack/react-router": "^1.170.41",
-    "@tanstack/react-router-ssr-query": "^1.167.3",
-    "@tanstack/react-start": "^1.168.60",
-    "effect": "^4.0.2",
-    "react": "^19.3.0",
-    "@unisian/capability": "0.1.0",
-    "@unisian/shopify-auth": "0.1.0",
-    "@unisian/effect-observability": "0.1.0",
-    "@unisian/shopify-sessions": "0.1.0"
-  },
-  "scripts": {}
+  "version": "0.0.0-stage",
+  "stub": true,
+  "description": "Temporary package placeholder for staged publishing"
 }

package/dist/browser-error-contract.d.mts

@@ -1,15 +0,0 @@
-import * as Schema from "effect/Schema";
-//#region src/browser-error-contract.d.ts
-export declare const browserErrorLimits: {
-  readonly message: 2000;
-  readonly path: 500;
-  readonly stack: 8000;
-};
-export declare const reportBrowserErrorContract: import("@unisian/capability").Contract<"reportBrowserError", Schema.Struct<{
-  readonly message: Schema.String;
-  readonly path: Schema.String;
-  readonly stack: Schema.optional<Schema.String>;
-}>, Schema.Struct<{
-  readonly reference: Schema.String;
-}>, Schema.Never>;
-//#endregion

package/dist/browser-error-contract.mjs

@@ -1,20 +0,0 @@
-import * as Schema from "effect/Schema";
-import { defineContract } from "@unisian/capability";
-//#region src/browser-error-contract.ts
-const browserErrorLimits = {
-	message: 2e3,
-	path: 500,
-	stack: 8e3
-};
-const reportBrowserErrorContract = defineContract("reportBrowserError", {
-	description: "Log an error that broke a page in the merchant's browser, under this request's reference, and return the reference for the error page to show",
-	failure: Schema.Never,
-	input: Schema.Struct({
-		message: Schema.String.check(Schema.isMaxLength(browserErrorLimits.message)),
-		path: Schema.String.check(Schema.isMaxLength(browserErrorLimits.path)),
-		stack: Schema.optional(Schema.String.check(Schema.isMaxLength(browserErrorLimits.stack)))
-	}),
-	output: Schema.Struct({ reference: Schema.String })
-});
-//#endregion
-export { browserErrorLimits, reportBrowserErrorContract };

package/dist/browser-error-report.d.mts

@@ -1,8 +0,0 @@
-import { reportBrowserErrorContract } from "./browser-error-contract.mjs";
-import { command } from "./client.mjs";
-import { QueryClient } from "@tanstack/react-query";
-//#region src/browser-error-report.d.ts
-export type BrowserErrorReport = ReturnType<typeof command<typeof reportBrowserErrorContract>>;
-export declare const reportBrowserErrors: (queryClient: QueryClient, report: BrowserErrorReport) => (cause: unknown) => void;
-export declare const useBrowserErrorReference: (report: BrowserErrorReport, cause: unknown) => string | undefined;
-//#endregion

package/dist/browser-error-report.mjs

@@ -1,29 +0,0 @@
-import { caughtError, decodeReport } from "./report.mjs";
-import { browserErrorLimits, reportBrowserErrorContract } from "./browser-error-contract.mjs";
-import * as Schema from "effect/Schema";
-import { MutationObserver, useMutationState } from "@tanstack/react-query";
-//#region src/browser-error-report.ts
-const reportedMessage = (cause) => caughtError(cause).message.slice(0, browserErrorLimits.message);
-const reportBrowserErrors = (queryClient, report) => (cause) => {
-	if (decodeReport(cause).reference !== "none") return;
-	new MutationObserver(queryClient, report).mutate({
-		message: reportedMessage(cause),
-		path: globalThis.location.pathname.slice(0, browserErrorLimits.path),
-		stack: caughtError(cause).stack?.slice(0, browserErrorLimits.stack)
-	}).catch(() => null);
-};
-const isReportInput = Schema.is(reportBrowserErrorContract.input);
-const isReportOutput = Schema.is(reportBrowserErrorContract.output);
-const useBrowserErrorReference = (report, cause) => {
-	const message = reportedMessage(cause);
-	return useMutationState({
-		filters: {
-			mutationKey: report.mutationKey,
-			predicate: ({ state }) => isReportInput(state.variables) && state.variables.message === message,
-			status: "success"
-		},
-		select: ({ state }) => isReportOutput(state.data) ? state.data.reference : void 0
-	}).at(-1);
-};
-//#endregion
-export { reportBrowserErrors, useBrowserErrorReference };

package/dist/client.d.mts

@@ -1,31 +0,0 @@
-import { CapabilityFailureError } from "./failure.mjs";
-import { BrowserErrorReport, reportBrowserErrors, useBrowserErrorReference } from "./browser-error-report.mjs";
-import { useCommandForm } from "./command-form.mjs";
-import { AppRouterOptions, createAppRouter } from "./router.mjs";
-import * as Schema from "effect/Schema";
-import * as Option from "effect/Option";
-import { AnyContract, FailureOf, InputOf, OutputOf } from "@unisian/capability";
-import { QueryClient, QueryKey, UseSuspenseQueryOptions } from "@tanstack/react-query";
-//#region src/client.d.ts
-export type ServerFn<ContractType extends AnyContract> = (options: {
-  readonly data: InputOf<ContractType>["Encoded"];
-  readonly headers?: Record<string, string>;
-}) => Promise<Schema.Json>;
-export interface PerCall {
-  readonly headers?: Record<string, string> | undefined;
-  readonly key?: Schema.Json | undefined;
-}
-export declare const query: <ContractType extends AnyContract>(contract: ContractType, serverFn: ServerFn<ContractType>) => (input: InputOf<ContractType>["Type"], perCall?: PerCall) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Schema.Json, CapabilityFailureError<FailureOf<ContractType>["Type"]>, OutputOf<ContractType>["Type"], readonly [ContractType["name"], InputOf<ContractType>["Encoded"], ...Schema.Json[]]>, "queryFn"> & {
-  queryFn?: import("@tanstack/react-query").QueryFunction<Schema.Json, readonly [ContractType["name"], InputOf<ContractType>["Encoded"], ...Schema.Json[]], never>;
-} & import("@tanstack/react-query").QueryKeyWithDataTag<readonly [ContractType["name"], InputOf<ContractType>["Encoded"], ...Schema.Json[]], Schema.Json, CapabilityFailureError<FailureOf<ContractType>["Type"]>>;
-export declare const cachedData: <Output>(client: QueryClient, options: {
-  readonly queryKey: QueryKey;
-  readonly select?: ((encoded: Schema.Json) => Output) | undefined;
-}) => Output | undefined;
-export declare const cachedQuery: <QueryFnData, QueryError, Data, Key extends QueryKey>(client: QueryClient, options: UseSuspenseQueryOptions<QueryFnData, QueryError, Data, Key>) => Promise<Option.Option<Data>>;
-export interface CommandOptions extends PerCall {
-  readonly invalidates: readonly AnyContract[];
-}
-export declare const command: <ContractType extends AnyContract>(contract: ContractType, serverFn: ServerFn<ContractType>, options: CommandOptions) => import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<OutputOf<ContractType>["Type"], CapabilityFailureError<FailureOf<ContractType>["Type"]>, InputOf<ContractType>["Type"], unknown>, "mutationKey">;
-//#endregion
-export { type AppRouterOptions, type BrowserErrorReport, createAppRouter, reportBrowserErrors, useBrowserErrorReference, useCommandForm };

package/dist/client.mjs

@@ -1,63 +0,0 @@
-import { CapabilityFailureError } from "./failure.mjs";
-import { wireFor } from "./wire.mjs";
-import { reportBrowserErrors, useBrowserErrorReference } from "./browser-error-report.mjs";
-import { useCommandForm } from "./command-form.mjs";
-import { createAppRouter } from "./router.mjs";
-import * as Schema from "effect/Schema";
-import * as Option from "effect/Option";
-import { environmentManager, mutationOptions, queryOptions } from "@tanstack/react-query";
-//#region src/client.ts
-const transportRetries = 2;
-const keyFor = (head, { key }) => key === void 0 ? head : [...head, key];
-const callerFor = (contract, serverFn) => {
-	const encodeInput = Schema.encodeSync(contract.input);
-	const decodeOutput = Schema.decodeUnknownSync(Schema.toCodecJson(contract.output));
-	const { decode } = wireFor(contract.failure);
-	return {
-		call: (data, { headers }) => serverFn(headers === void 0 ? { data } : {
-			data,
-			headers
-		}).then(decode),
-		decodeOutput,
-		encodeInput
-	};
-};
-const query = (contract, serverFn) => {
-	const { encodeInput, decodeOutput, call } = callerFor(contract, serverFn);
-	return (input, perCall = {}) => {
-		const data = encodeInput(input);
-		return queryOptions({
-			queryFn: () => call(data, perCall),
-			queryKey: keyFor([contract.name, data], perCall),
-			retry: (failureCount, error) => !(error instanceof CapabilityFailureError) && failureCount < (environmentManager.isServer() ? 0 : transportRetries),
-			select: decodeOutput
-		});
-	};
-};
-const cachedData = (client, options) => {
-	const encoded = client.getQueryData(options.queryKey);
-	return encoded === void 0 ? void 0 : options.select?.(encoded);
-};
-const cachedQuery = (client, options) => {
-	const { queryFn } = options;
-	return queryFn === void 0 ? Promise.resolve(Option.none()) : client.query({
-		...options,
-		queryFn,
-		staleTime: "static"
-	}).then(Option.some);
-};
-const command = (contract, serverFn, options) => {
-	const { encodeInput, decodeOutput, call } = callerFor(contract, serverFn);
-	return mutationOptions({
-		mutationFn: async (input, { client }) => {
-			try {
-				return decodeOutput(await call(encodeInput(input), options));
-			} finally {
-				await Promise.all(options.invalidates.map(({ name }) => client.invalidateQueries({ queryKey: [name] })));
-			}
-		},
-		mutationKey: keyFor([contract.name], options)
-	});
-};
-//#endregion
-export { cachedData, cachedQuery, command, createAppRouter, query, reportBrowserErrors, useBrowserErrorReference, useCommandForm };

package/dist/command-form.d.mts

@@ -1,36 +0,0 @@
-import { CapabilityFailureError } from "./failure.mjs";
-import { InputSchema } from "@unisian/capability";
-import { UseMutationOptions } from "@tanstack/react-query";
-//#region src/command-form.d.ts
-interface FormMessage {
-  readonly message: string;
-}
-interface SavingForm<Values> {
-  readonly fieldInfo: object;
-  readonly reset: (values: Values) => void;
-  setErrorMap(errorMap: {
-    readonly onSubmit: {
-      readonly fields: Record<string, FormMessage>;
-      readonly form: readonly FormMessage[] | undefined;
-    };
-  }): void;
-}
-export declare const useCommandForm: <Input extends InputSchema, Failure>({ command, contract, defaultValues, onSaved }: {
-  readonly command: UseMutationOptions<Input["Type"], CapabilityFailureError<Failure>, Input["Type"]>;
-  readonly contract: {
-    readonly input: Input;
-  };
-  readonly defaultValues: Input["Type"];
-  readonly onSaved?: (output: Input["Type"]) => void;
-}) => {
-  defaultValues: Input["Encoded"];
-  onSubmit: ({ formApi, value }: {
-    readonly formApi: SavingForm<Input["Encoded"]>;
-    readonly value: Input["Encoded"];
-  }) => Promise<void>;
-  validationLogic: import("@tanstack/react-form").ValidationLogicFn;
-  validators: {
-    onDynamic: import("effect/StandardSchema").StandardSchemaV1<Input["Encoded"], Input["Type"]> & Input;
-  };
-};
-//#endregion

package/dist/command-form.mjs

@@ -1,61 +0,0 @@
-import { CapabilityFailureError, isFieldIssues, isMerchantFacing } from "./failure.mjs";
-import { input } from "./input.mjs";
-import * as Schema from "effect/Schema";
-import { useMutation } from "@tanstack/react-query";
-import { revalidateLogic } from "@tanstack/react-form";
-//#region src/command-form.ts
-const issuesIn = (cause) => {
-	if (!(cause instanceof CapabilityFailureError)) return [];
-	const failure = cause.failure;
-	return [...isMerchantFacing(failure) ? [{
-		message: failure.merchantMessage,
-		path: []
-	}] : [], ...isFieldIssues(failure) ? failure.fieldIssues : []];
-};
-const fieldName = (path) => path.map((segment, index) => {
-	if (/^\d+$/u.test(segment)) return `[${segment}]`;
-	return index === 0 ? segment : `.${segment}`;
-}).join("");
-const showOnForm = (form, cause) => {
-	const issues = issuesIn(cause).map((issue) => ({
-		...issue,
-		name: fieldName(issue.path)
-	}));
-	if (issues.length === 0) return false;
-	const isField = (name) => Object.hasOwn(form.fieldInfo, name);
-	const fields = Object.fromEntries(issues.filter(({ name }) => isField(name)).toReversed().map(({ message, name }) => [name, { message }]));
-	const formIssues = issues.filter(({ name }) => !isField(name)).map(({ message }) => ({ message }));
-	form.setErrorMap({ onSubmit: {
-		fields,
-		form: formIssues.length === 0 ? void 0 : formIssues
-	} });
-	return true;
-};
-const commandFormOptions = (contract, save, defaultValues, onSaved) => {
-	const encodeSync = Schema.encodeSync(contract.input);
-	const encode = (values) => encodeSync(values, { disableChecks: true });
-	const decode = Schema.decodeUnknownSync(contract.input);
-	return {
-		defaultValues: encode(defaultValues),
-		onSubmit: ({ formApi, value }) => save(decode(value)).then((output) => {
-			formApi.reset(encode(output));
-			onSaved?.(output);
-		}, (error) => {
-			showOnForm(formApi, error);
-		}),
-		validationLogic: revalidateLogic({
-			mode: "submit",
-			modeAfterSubmission: "change"
-		}),
-		validators: { onDynamic: input(contract) }
-	};
-};
-const useCommandForm = ({ command, contract, defaultValues, onSaved }) => {
-	const { mutateAsync } = useMutation({
-		...command,
-		throwOnError: (error) => issuesIn(error).length === 0
-	});
-	return commandFormOptions(contract, mutateAsync, defaultValues, onSaved);
-};
-//#endregion
-export { commandFormOptions, showOnForm, useCommandForm };

package/dist/failure.d.mts

@@ -1,33 +0,0 @@
-import { ErrorReport } from "./report.mjs";
-import * as Schema from "effect/Schema";
-//#region src/failure.d.ts
-export declare class CapabilityFailureError<Failure = unknown> extends Error {
-  readonly name = "CapabilityFailureError";
-  readonly report: ErrorReport;
-  readonly failure: Failure | undefined;
-  constructor(report: ErrorReport, failure: Failure | undefined);
-}
-export declare const isFailure: <Failure extends {
-  readonly _tag: string;
-}, const Tag extends Failure["_tag"]>(error: CapabilityFailureError<Failure> | Error | null | undefined, tag: Tag) => error is CapabilityFailureError<Extract<Failure, {
-  readonly _tag: Tag;
-}>>;
-export declare const MerchantFacing: Schema.Struct<{
-  readonly merchantMessage: Schema.String;
-}>;
-export declare const isMerchantFacing: <I>(input: I) => input is I & {
-  readonly merchantMessage: string;
-};
-export declare const FieldIssues: Schema.Struct<{
-  readonly fieldIssues: Schema.$Array<Schema.Struct<{
-    readonly message: Schema.String;
-    readonly path: Schema.$Array<Schema.String>;
-  }>>;
-}>;
-export declare const isFieldIssues: <I>(input: I) => input is I & {
-  readonly fieldIssues: readonly {
-    readonly message: string;
-    readonly path: readonly string[];
-  }[];
-};
-//#endregion

package/dist/failure.mjs

@@ -1,24 +0,0 @@
-import { encodeReport } from "./report.mjs";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-//#region src/failure.ts
-var CapabilityFailureError = class extends Error {
-	name = "CapabilityFailureError";
-	report;
-	failure;
-	constructor(report, failure) {
-		super(encodeReport(report));
-		this.report = report;
-		this.failure = failure;
-	}
-};
-const isFailure = (error, tag) => error instanceof CapabilityFailureError && Predicate.isTagged(error.failure, tag);
-const MerchantFacing = Schema.Struct({ merchantMessage: Schema.String });
-const isMerchantFacing = Schema.is(MerchantFacing);
-const FieldIssues = Schema.Struct({ fieldIssues: Schema.Array(Schema.Struct({
-	message: Schema.String,
-	path: Schema.Array(Schema.String)
-})) });
-const isFieldIssues = Schema.is(FieldIssues);
-//#endregion
-export { CapabilityFailureError, FieldIssues, MerchantFacing, isFailure, isFieldIssues, isMerchantFacing };

package/dist/function-id.d.mts

@@ -1,7 +0,0 @@
-//#region src/function-id.d.ts
-export declare const serverFnNameFor: (contractName: string) => string;
-export declare const functionIds: () => ({ filename, functionName }: {
-  filename: string;
-  functionName: string;
-}) => string;
-//#endregion

package/dist/function-id.mjs

@@ -1,18 +0,0 @@
-//#region src/function-id.ts
-const SERVER_FN_SUFFIX = "Fn";
-const HANDLER_SUFFIX = `${SERVER_FN_SUFFIX}_createServerFn_handler`;
-const serverFnNameFor = (contractName) => `${contractName}${SERVER_FN_SUFFIX}`;
-const functionIds = () => {
-	const sources = /* @__PURE__ */ new Map();
-	return ({ filename, functionName }) => {
-		const source = `${filename} ${functionName}`;
-		if (!functionName.endsWith(HANDLER_SUFFIX)) throw new Error(`${source}: name a server function <contract name>${SERVER_FN_SUFFIX}, so its URL names the contract`);
-		const id = functionName.slice(0, -HANDLER_SUFFIX.length);
-		const claimed = sources.get(id);
-		if (claimed !== void 0 && claimed !== source) throw new Error(`${source} and ${claimed} both serve ${id}; declare its server function once and import it`);
-		sources.set(id, source);
-		return id;
-	};
-};
-//#endregion
-export { functionIds, serverFnNameFor };

package/dist/index.d.mts

@@ -1,5 +0,0 @@
-import { ErrorReport, PUBLIC_ERROR_MESSAGE, decodeReport, encodeReport, errorPageHtml, errorReport } from "./report.mjs";
-import { CapabilityFailureError, FieldIssues, MerchantFacing, isFailure, isFieldIssues, isMerchantFacing } from "./failure.mjs";
-import { browserErrorLimits, reportBrowserErrorContract } from "./browser-error-contract.mjs";
-import { input } from "./input.mjs";
-export { CapabilityFailureError, ErrorReport, FieldIssues, MerchantFacing, PUBLIC_ERROR_MESSAGE, browserErrorLimits, decodeReport, encodeReport, errorPageHtml, errorReport, input, isFailure, isFieldIssues, isMerchantFacing, reportBrowserErrorContract };

package/dist/index.mjs

@@ -1,5 +0,0 @@
-import { ErrorReport, PUBLIC_ERROR_MESSAGE, decodeReport, encodeReport, errorPageHtml, errorReport } from "./report.mjs";
-import { CapabilityFailureError, FieldIssues, MerchantFacing, isFailure, isFieldIssues, isMerchantFacing } from "./failure.mjs";
-import { input } from "./input.mjs";
-import { browserErrorLimits, reportBrowserErrorContract } from "./browser-error-contract.mjs";
-export { CapabilityFailureError, ErrorReport, FieldIssues, MerchantFacing, PUBLIC_ERROR_MESSAGE, browserErrorLimits, decodeReport, encodeReport, errorPageHtml, errorReport, input, isFailure, isFieldIssues, isMerchantFacing, reportBrowserErrorContract };

package/dist/input.d.mts

@@ -1,6 +0,0 @@
-import { InputSchema } from "@unisian/capability";
-//#region src/input.d.ts
-export declare const input: <Input extends InputSchema>(contract: {
-  readonly input: Input;
-}) => import("effect/StandardSchema").StandardSchemaV1<Input["Encoded"], Input["Type"]> & Input;
-//#endregion

package/dist/input.mjs

@@ -1,5 +0,0 @@
-import * as Schema from "effect/Schema";
-//#region src/input.ts
-const input = (contract) => Schema.toStandardSchemaV1(contract.input);
-//#endregion
-export { input };

package/dist/middleware.d.mts

@@ -1,14 +0,0 @@
-import * as Cause from "effect/Cause";
-import { RequestLogTags, RunTags } from "@unisian/effect-observability";
-import * as Effect from "effect/Effect";
-import { RequestServerFn } from "@tanstack/react-start";
-//#region src/middleware.d.ts
-export interface RequestMiddlewareAnswers<Added, E> {
-  readonly refuse: (request: Request, cause: Cause.Cause<E>, log: RequestLogTags) => Response;
-  readonly answer?: (response: Response, added: Added) => Response;
-}
-export declare const respond: <E>(name: string, tags: RunTags, refuse: (cause: Cause.Cause<E>) => Response) => (effect: Effect.Effect<Response, E>) => Promise<Response>;
-export declare const requestMiddleware: <Added extends object, E>(name: string, run: (request: Request, pathname: string) => Effect.Effect<Added, E>, answers: RequestMiddlewareAnswers<Added, E>) => RequestServerFn<object, undefined, Added & {
-  readonly log: RequestLogTags;
-}>;
-//#endregion

package/dist/middleware.mjs

@@ -1,24 +0,0 @@
-import * as Exit from "effect/Exit";
-import { requestLogTags, runPromiseExit } from "@unisian/effect-observability";
-//#region src/middleware.ts
-const isSettled = (effect) => Exit.isExit(effect);
-const settle = (name, tags, effect) => isSettled(effect) ? Promise.resolve(effect) : effect.pipe(runPromiseExit(name, tags));
-const respond = (name, tags, refuse) => async (effect) => {
-	const exit = await settle(name, tags, effect);
-	return Exit.isSuccess(exit) ? exit.value : refuse(exit.cause);
-};
-const requestMiddleware = (name, run, answers) => async ({ request, pathname, next: route }) => {
-	const log = requestLogTags(request);
-	const exit = await settle(name, log, run(request, pathname));
-	if (Exit.isFailure(exit)) return answers.refuse(request, exit.cause, log);
-	const result = await route({ context: {
-		...exit.value,
-		log
-	} });
-	return answers.answer === void 0 ? result : {
-		...result,
-		response: answers.answer(result.response, exit.value)
-	};
-};
-//#endregion
-export { requestMiddleware, respond };

package/dist/report-browser-error.d.mts

@@ -1,10 +0,0 @@
-import { RequestReference } from "@unisian/effect-observability";
-//#region src/report-browser-error.d.ts
-export declare const reportBrowserError: import("@unisian/capability").Capability<import("@unisian/capability").Contract<"reportBrowserError", import("effect/Schema").Struct<{
-  readonly message: import("effect/Schema").String;
-  readonly path: import("effect/Schema").String;
-  readonly stack: import("effect/Schema").optional<import("effect/Schema").String>;
-}>, import("effect/Schema").Struct<{
-  readonly reference: import("effect/Schema").String;
-}>, import("effect/Schema").Never>, RequestReference>;
-//#endregion

package/dist/report-browser-error.mjs

@@ -1,15 +0,0 @@
-import { reportBrowserErrorContract } from "./browser-error-contract.mjs";
-import { implement } from "@unisian/capability";
-import { RequestReference } from "@unisian/effect-observability";
-import * as Effect from "effect/Effect";
-//#region src/report-browser-error.ts
-const reportBrowserError = implement(reportBrowserErrorContract, ({ message, path, stack }) => Effect.gen(function* logBrowserError() {
-	yield* Effect.logError("browser error", {
-		browserMessage: message,
-		browserPath: path,
-		browserStack: stack ?? null
-	});
-	return yield* RequestReference;
-}));
-//#endregion
-export { reportBrowserError };

package/dist/report.d.mts

@@ -1,15 +0,0 @@
-import * as Schema from "effect/Schema";
-import * as Cause from "effect/Cause";
-//#region src/report.d.ts
-export declare const PUBLIC_ERROR_MESSAGE = "Something went wrong loading this app. Try again, and if it keeps happening, quote this reference.";
-export declare const ErrorReport: Schema.Struct<{
-  readonly diagnostic: Schema.optional<Schema.String>;
-  readonly merchantMessage: Schema.optional<Schema.String>;
-  readonly reference: Schema.String;
-}>;
-export type ErrorReport = typeof ErrorReport.Type;
-export declare const errorReport: (reference: string, cause: Cause.Cause<unknown>, merchantMessage?: string) => ErrorReport;
-export declare const encodeReport: (report: ErrorReport) => string;
-export declare const decodeReport: (cause: unknown) => ErrorReport;
-export declare const errorPageHtml: (report: ErrorReport) => string;
-//#endregion

package/dist/report.mjs

@@ -1,31 +0,0 @@
-import * as Schema from "effect/Schema";
-import * as Cause from "effect/Cause";
-import * as Option from "effect/Option";
-//#region src/report.ts
-const PUBLIC_ERROR_MESSAGE = "Something went wrong loading this app. Try again, and if it keeps happening, quote this reference.";
-const ErrorReport = Schema.Struct({
-	diagnostic: Schema.optional(Schema.String),
-	merchantMessage: Schema.optional(Schema.String),
-	reference: Schema.String
-});
-const REPORT_PREFIX = "error-report:";
-const decodeReportJson = Schema.decodeUnknownOption(Schema.fromJsonString(ErrorReport));
-const errorReport = (reference, cause, merchantMessage) => ({
-	diagnostic: import.meta.env.DEV ? Cause.pretty(cause) : void 0,
-	merchantMessage,
-	reference
-});
-const encodeReport = (report) => `${REPORT_PREFIX}${JSON.stringify(report)}`;
-const caughtError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
-const decodeReport = (cause) => {
-	const { message } = caughtError(cause);
-	if (!message.startsWith(REPORT_PREFIX)) return import.meta.env.DEV ? {
-		diagnostic: message,
-		reference: "none"
-	} : { reference: "none" };
-	return Option.getOrElse(decodeReportJson(message.slice(13)), () => ({ reference: "none" }));
-};
-const escapeHtml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
-const errorPageHtml = (report) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Something went wrong</title></head><body><main><h1>Something went wrong</h1><p>${escapeHtml(PUBLIC_ERROR_MESSAGE)}</p><p>Reference: <code>${escapeHtml(report.reference)}</code></p>${report.diagnostic === void 0 ? "" : `<pre>${escapeHtml(report.diagnostic)}</pre>`}</main></body></html>`;
-//#endregion
-export { ErrorReport, PUBLIC_ERROR_MESSAGE, caughtError, decodeReport, encodeReport, errorPageHtml, errorReport };

package/dist/router.d.mts

@@ -1,10 +0,0 @@
-import { BrowserErrorReport } from "./browser-error-report.mjs";
-import { AnyRoute, Router, RouterOptions } from "@tanstack/react-router";
-//#region src/router.d.ts
-type PageComponents = Required<Pick<RouterOptions<AnyRoute, "never">, "defaultErrorComponent">> & Pick<RouterOptions<AnyRoute, "never">, "defaultNotFoundComponent" | "defaultPendingComponent">;
-export type AppRouterOptions<RouteTree extends AnyRoute> = PageComponents & {
-  readonly routeTree: RouteTree;
-  readonly browserErrorReport: BrowserErrorReport;
-};
-export declare const createAppRouter: <RouteTree extends AnyRoute>({ routeTree, browserErrorReport, ...components }: AppRouterOptions<RouteTree>) => Router<RouteTree>;
-//#endregion

package/dist/router.mjs

@@ -1,27 +0,0 @@
-import { reportBrowserErrors } from "./browser-error-report.mjs";
-import { QueryClient } from "@tanstack/react-query";
-import { createRouter } from "@tanstack/react-router";
-import { setupRouterSsrQueryIntegration } from "@tanstack/react-router-ssr-query";
-//#region src/router.ts
-const createAppRouter = ({ routeTree, browserErrorReport, ...components }) => {
-	const queryClient = new QueryClient({ defaultOptions: { queries: {
-		gcTime: 6e5,
-		refetchOnWindowFocus: false,
-		staleTime: 3e5
-	} } });
-	const router = createRouter({
-		...components,
-		context: { queryClient },
-		defaultOnCatch: reportBrowserErrors(queryClient, browserErrorReport),
-		defaultPreload: "viewport",
-		routeTree,
-		scrollRestoration: true
-	});
-	setupRouterSsrQueryIntegration({
-		queryClient,
-		router
-	});
-	return router;
-};
-//#endregion
-export { createAppRouter };

package/dist/serve.d.mts

@@ -1,31 +0,0 @@
-import { reportBrowserError } from "./report-browser-error.mjs";
-import * as Schema from "effect/Schema";
-import { AnyContract, Capability, InputOf } from "@unisian/capability";
-import { RequestLogTags, RequestReference } from "@unisian/effect-observability";
-import { AuthenticatedShop, CurrentShop, ShopifyAdmin, ShopifyApp, ShopifyLayerConfig } from "@unisian/shopify-auth";
-import * as Layer from "effect/Layer";
-import { ShopDomain } from "@unisian/shopify-sessions";
-import { HttpClient } from "effect/http";
-//#region src/serve.d.ts
-export interface ServeContext {
-  readonly shopify: AuthenticatedShop;
-  readonly log: RequestLogTags;
-}
-export interface ServeConfig<Services, ServicesError> extends ShopifyLayerConfig {
-  readonly services?: Layer.Layer<Services, ServicesError> | undefined;
-}
-export type Provided<Services> = CurrentShop | ShopifyAdmin | ShopifyApp | HttpClient.HttpClient | RequestReference | Services;
-export interface ServerFnCall<ContractType extends AnyContract, Context> {
-  readonly data: InputOf<ContractType>["Type"];
-  readonly context: Context;
-  readonly serverFnMeta: {
-    readonly name: string;
-  };
-}
-export declare const serveWith: <Context, Services, ServicesError>(callerOf: (context: Context) => {
-  readonly shop: ShopDomain;
-  readonly log: RequestLogTags;
-}, layerFor: (context: Context) => Layer.Layer<Services, ServicesError>) => <ContractType extends AnyContract, Requirements extends Services | CurrentShop | RequestReference>(capability: Capability<ContractType, Requirements>) => ({ data, context, serverFnMeta }: ServerFnCall<ContractType, Context>) => Promise<Schema.Json>;
-export declare const makeServe: <Services = never, ServicesError = never>(config: () => ServeConfig<Services, ServicesError>) => <ContractType extends AnyContract, Requirements extends (HttpClient.HttpClient | ShopifyAdmin | ShopifyApp | Exclude<Services, CurrentShop | RequestReference>) | CurrentShop | RequestReference>(capability: Capability<ContractType, Requirements>) => ({ data, context, serverFnMeta }: ServerFnCall<ContractType, ServeContext>) => Promise<Schema.Json>;
-//#endregion
-export { reportBrowserError };

package/dist/serve.mjs

@@ -1,34 +0,0 @@
-import { wireFor } from "./wire.mjs";
-import { serverFnNameFor } from "./function-id.mjs";
-import { reportBrowserError } from "./report-browser-error.mjs";
-import * as Schema from "effect/Schema";
-import { RequestReference, logFailure, runPromiseExit } from "@unisian/effect-observability";
-import { CurrentShop, ShopifyAdmin, shopifyLayer } from "@unisian/shopify-auth";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-//#region src/serve.ts
-const serveWith = (callerOf, layerFor) => (capability) => {
-	const { contract } = capability;
-	const encodeOutput = Schema.encodeEffect(Schema.toCodecJson(contract.output));
-	const wire = wireFor(contract.failure);
-	const serverFnName = serverFnNameFor(contract.name);
-	return async ({ data, context, serverFnMeta }) => {
-		if (serverFnMeta.name !== serverFnName) throw new Error(`${serverFnMeta.name} serves ${contract.name}; name it ${serverFnName} so its URL names the contract`);
-		const { shop, log } = callerOf(context);
-		const layer = Layer.mergeAll(layerFor(context), Layer.succeed(CurrentShop, { shop }), Layer.succeed(RequestReference, { reference: log.reference })).pipe(Layer.orDie);
-		const exit = await capability.handler(data).pipe(Effect.flatMap((output) => Effect.orDie(encodeOutput(output))), Effect.provide(layer), Effect.tapCause((cause) => logFailure("server function", cause)), runPromiseExit(contract.name, {
-			...log,
-			shop
-		}));
-		return wire.encode(exit, log.reference);
-	};
-};
-const makeServe = (config) => serveWith((context) => ({
-	log: context.log,
-	shop: context.shopify.shop
-}), (context) => {
-	const { services, ...shopify } = config();
-	return Layer.mergeAll(ShopifyAdmin.layer(context.shopify).pipe(Layer.provideMerge(shopifyLayer(shopify))), services ?? Layer.empty);
-});
-//#endregion
-export { makeServe, reportBrowserError, serveWith };

package/dist/wire.mjs

@@ -1,32 +0,0 @@
-import { ErrorReport, errorReport } from "./report.mjs";
-import { CapabilityFailureError, isMerchantFacing } from "./failure.mjs";
-import * as Schema from "effect/Schema";
-import * as Cause from "effect/Cause";
-import * as Exit from "effect/Exit";
-//#region src/wire.ts
-const isErrorReport = Schema.is(ErrorReport);
-const reportIn = (cause) => cause.reasons.filter(Cause.isDieReason).map((reason) => reason.defect).find(isErrorReport) ?? { reference: "none" };
-const wireFor = (failure) => {
-	const codec = Schema.toCodecJson(Schema.Exit(Schema.Json, failure, Schema.Defect()));
-	const encodeExit = Schema.encodeSync(codec);
-	const decodeExit = Schema.decodeSync(codec);
-	const isContractFailure = Schema.is(failure);
-	const encode = (exit, reference) => {
-		if (Exit.isSuccess(exit)) return encodeExit(exit);
-		const failures = exit.cause.reasons.filter(Cause.isFailReason).filter((reason) => isContractFailure(reason.error));
-		const merchantMessage = failures.map((reason) => reason.error).find(isMerchantFacing)?.merchantMessage;
-		return encodeExit(Exit.failCause(Cause.fromReasons([...failures, Cause.makeDieReason(errorReport(reference, exit.cause, merchantMessage))])));
-	};
-	const decode = (wire) => {
-		const exit = decodeExit(wire);
-		if (Exit.isSuccess(exit)) return exit.value;
-		const contractFailure = exit.cause.reasons.find(Cause.isFailReason)?.error;
-		throw new CapabilityFailureError(reportIn(exit.cause), contractFailure);
-	};
-	return {
-		decode,
-		encode
-	};
-};
-//#endregion
-export { wireFor };