@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/recipes/thumb-picker/menu.js

@@ -0,0 +1,127 @@
+import { List } from "./list.js";
+import { useEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AnimatePresence, motion, useReducedMotion } from "motion/react";
+import { createPortal } from "react-dom";
+//#region src/recipes/thumb-picker/menu.tsx
+const EASE = [
+	.23,
+	1,
+	.32,
+	1
+];
+const SPRING = {
+	type: "spring",
+	duration: .18,
+	bounce: .15
+};
+const SLIDE = {
+	type: "spring",
+	duration: .28,
+	bounce: .1
+};
+const FADE = {
+	duration: .16,
+	ease: EASE
+};
+const AT_ONCE = { duration: 0 };
+const BEHIND = {
+	x: -104,
+	y: -28
+};
+const SHAKE = [
+	0,
+	-6,
+	5,
+	-3,
+	2,
+	0
+].map((x) => `translateX(${x}px)`);
+/**
+* Where letting go will take you, at the top centre of the screen and
+* never under the fingers, over everything else dimmed and blurred: the
+* open list in the middle, and each list it was opened from drawn back to
+* the top left, smaller and fainter. It zooms in as it shows; an opened
+* list slides in from the right and slides back out as the swipe goes
+* back. Each time `shakes` counts up, the menu shakes once. None of it
+* moves for those who ask for less motion.
+*/
+function Menu(props) {
+	const still = useReducedMotion() === true;
+	const shaking = useRef(null);
+	useEffect(() => {
+		if (props.shakes === 0 || still) return;
+		shaking.current?.animate({ transform: SHAKE }, {
+			duration: 320,
+			easing: "ease-out"
+		});
+	}, [props.shakes, still]);
+	if (typeof document === "undefined") return null;
+	const columns = props.columns ?? [];
+	const last = columns.length - 1;
+	return createPortal(/* @__PURE__ */ jsxs(AnimatePresence, { children: [props.columns !== void 0 && /* @__PURE__ */ jsx(motion.div, {
+		"aria-hidden": "true",
+		initial: { opacity: 0 },
+		animate: { opacity: 1 },
+		exit: { opacity: 0 },
+		transition: still ? AT_ONCE : FADE,
+		className: "pointer-events-none fixed inset-0 z-[99] bg-black/40 backdrop-blur-sm"
+	}, "scrim"), props.columns !== void 0 && /* @__PURE__ */ jsx(motion.div, {
+		"aria-live": "polite",
+		initial: {
+			opacity: 0,
+			scale: .94
+		},
+		animate: {
+			opacity: 1,
+			scale: 1
+		},
+		exit: {
+			opacity: 0,
+			scale: .97
+		},
+		transition: still ? AT_ONCE : FADE,
+		className: "pointer-events-none fixed top-[calc(env(safe-area-inset-top)+6rem)] left-1/2 z-[100] origin-top text-sm text-popover-foreground",
+		children: /* @__PURE__ */ jsx("div", {
+			ref: shaking,
+			children: /* @__PURE__ */ jsx(AnimatePresence, {
+				initial: false,
+				children: columns.map((column, depth) => {
+					const back = last - depth;
+					return /* @__PURE__ */ jsx(motion.div, {
+						style: { zIndex: depth },
+						initial: {
+							opacity: 0,
+							x: 56,
+							scale: .96
+						},
+						animate: {
+							opacity: back === 0 ? 1 : .5,
+							x: back * BEHIND.x,
+							y: back * BEHIND.y,
+							scale: 1 - back * .1
+						},
+						exit: {
+							opacity: 0,
+							x: 56,
+							scale: .96
+						},
+						transition: still ? AT_ONCE : SLIDE,
+						className: "absolute top-0 left-0 origin-top-left -translate-x-1/2 rounded-2xl border bg-popover shadow-lg",
+						children: /* @__PURE__ */ jsx(List, {
+							id: column.id,
+							choices: column.choices,
+							marked: column.marked,
+							here: column.here,
+							move: still ? AT_ONCE : SPRING
+						})
+					}, column.id);
+				})
+			})
+		})
+	}, "menu")] }), document.body);
+}
+//#endregion
+export { Menu };
+
+//# sourceMappingURL=menu.js.map

package/dist/recipes/thumb-picker/menu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu.js","names":[],"sources":["../../../src/recipes/thumb-picker/menu.tsx"],"sourcesContent":["import { AnimatePresence, motion, useReducedMotion } from 'motion/react';\nimport { useEffect, useRef } from 'react';\nimport { createPortal } from 'react-dom';\nimport type { TreeWalk } from '@kestack/use-gesture';\nimport type { Choice } from './choice.ts';\nimport { List } from './list.tsx';\n\nconst EASE = [0.23, 1, 0.32, 1] as const;\nconst SPRING = { type: 'spring', duration: 0.18, bounce: 0.15 } as const;\nconst SLIDE = { type: 'spring', duration: 0.28, bounce: 0.1 } as const;\nconst FADE = { duration: 0.16, ease: EASE } as const;\nconst AT_ONCE = { duration: 0 } as const;\n// How far, in px, each list behind the open one sits to the top left.\nconst BEHIND = { x: -104, y: -28 } as const;\n// A Wrong Way: the menu shakes side to side, once.\nconst SHAKE = [0, -6, 5, -3, 2, 0].map((x) => `translateX(${x}px)`);\n\ntype Column = TreeWalk.Column<Choice>;\n\n/**\n * Where letting go will take you, at the top centre of the screen and\n * never under the fingers, over everything else dimmed and blurred: the\n * open list in the middle, and each list it was opened from drawn back to\n * the top left, smaller and fainter. It zooms in as it shows; an opened\n * list slides in from the right and slides back out as the swipe goes\n * back. Each time `shakes` counts up, the menu shakes once. None of it\n * moves for those who ask for less motion.\n */\nexport function Menu(props: {\n  readonly columns: ReadonlyArray<Column> | undefined;\n  readonly shakes: number;\n}) {\n  const still = useReducedMotion() === true;\n  const shaking = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    if (props.shakes === 0 || still) return;\n    shaking.current?.animate(\n      { transform: SHAKE },\n      { duration: 320, easing: 'ease-out' },\n    );\n  }, [props.shakes, still]);\n  if (typeof document === 'undefined') return null;\n  const columns = props.columns ?? [];\n  const last = columns.length - 1;\n  return createPortal(\n    <AnimatePresence>\n      {props.columns !== undefined && (\n        <motion.div\n          key=\"scrim\"\n          aria-hidden=\"true\"\n          initial={{ opacity: 0 }}\n          animate={{ opacity: 1 }}\n          exit={{ opacity: 0 }}\n          transition={still ? AT_ONCE : FADE}\n          className=\"pointer-events-none fixed inset-0 z-[99] bg-black/40 backdrop-blur-sm\"\n        />\n      )}\n      {props.columns !== undefined && (\n        <motion.div\n          key=\"menu\"\n          aria-live=\"polite\"\n          initial={{ opacity: 0, scale: 0.94 }}\n          animate={{ opacity: 1, scale: 1 }}\n          exit={{ opacity: 0, scale: 0.97 }}\n          transition={still ? AT_ONCE : FADE}\n          className=\"pointer-events-none fixed top-[calc(env(safe-area-inset-top)+6rem)] left-1/2 z-[100] origin-top text-sm text-popover-foreground\"\n        >\n          <div ref={shaking}>\n            <AnimatePresence initial={false}>\n              {columns.map((column, depth) => {\n                const back = last - depth;\n                return (\n                  <motion.div\n                    key={column.id}\n                    style={{ zIndex: depth }}\n                    initial={{ opacity: 0, x: 56, scale: 0.96 }}\n                    animate={{\n                      opacity: back === 0 ? 1 : 0.5,\n                      x: back * BEHIND.x,\n                      y: back * BEHIND.y,\n                      scale: 1 - back * 0.1,\n                    }}\n                    exit={{ opacity: 0, x: 56, scale: 0.96 }}\n                    transition={still ? AT_ONCE : SLIDE}\n                    // Centred by `translate`, apart from the motion's `transform`.\n                    className=\"absolute top-0 left-0 origin-top-left -translate-x-1/2 rounded-2xl border bg-popover shadow-lg\"\n                  >\n                    <List\n                      id={column.id}\n                      choices={column.choices}\n                      marked={column.marked}\n                      here={column.here}\n                      move={still ? AT_ONCE : SPRING}\n                    />\n                  </motion.div>\n                );\n              })}\n            </AnimatePresence>\n          </div>\n        </motion.div>\n      )}\n    </AnimatePresence>,\n    document.body,\n  );\n}\n"],"mappings":";;;;;;AAOA,MAAM,OAAO;CAAC;CAAM;CAAG;CAAM;AAAC;AAC9B,MAAM,SAAS;CAAE,MAAM;CAAU,UAAU;CAAM,QAAQ;AAAK;AAC9D,MAAM,QAAQ;CAAE,MAAM;CAAU,UAAU;CAAM,QAAQ;AAAI;AAC5D,MAAM,OAAO;CAAE,UAAU;CAAM,MAAM;AAAK;AAC1C,MAAM,UAAU,EAAE,UAAU,EAAE;AAE9B,MAAM,SAAS;CAAE,GAAG;CAAM,GAAG;AAAI;AAEjC,MAAM,QAAQ;CAAC;CAAG;CAAI;CAAG;CAAI;CAAG;AAAC,CAAC,CAAC,KAAK,MAAM,cAAc,EAAE,IAAI;;;;;;;;;;AAalE,SAAgB,KAAK,OAGlB;CACD,MAAM,QAAQ,iBAAiB,MAAM;CACrC,MAAM,UAAU,OAAuB,IAAI;CAC3C,gBAAgB;EACd,IAAI,MAAM,WAAW,KAAK,OAAO;EACjC,QAAQ,SAAS,QACf,EAAE,WAAW,MAAM,GACnB;GAAE,UAAU;GAAK,QAAQ;EAAW,CACtC;CACF,GAAG,CAAC,MAAM,QAAQ,KAAK,CAAC;CACxB,IAAI,OAAO,aAAa,aAAa,OAAO;CAC5C,MAAM,UAAU,MAAM,WAAW,CAAC;CAClC,MAAM,OAAO,QAAQ,SAAS;CAC9B,OAAO,aACL,qBAAC,iBAAD,EAAA,UAAA,CACG,MAAM,YAAY,KAAA,KACjB,oBAAC,OAAO,KAAR;EAEE,eAAY;EACZ,SAAS,EAAE,SAAS,EAAE;EACtB,SAAS,EAAE,SAAS,EAAE;EACtB,MAAM,EAAE,SAAS,EAAE;EACnB,YAAY,QAAQ,UAAU;EAC9B,WAAU;CACX,GAPK,OAOL,GAEF,MAAM,YAAY,KAAA,KACjB,oBAAC,OAAO,KAAR;EAEE,aAAU;EACV,SAAS;GAAE,SAAS;GAAG,OAAO;EAAK;EACnC,SAAS;GAAE,SAAS;GAAG,OAAO;EAAE;EAChC,MAAM;GAAE,SAAS;GAAG,OAAO;EAAK;EAChC,YAAY,QAAQ,UAAU;EAC9B,WAAU;EAEV,UAAA,oBAAC,OAAD;GAAK,KAAK;GACR,UAAA,oBAAC,iBAAD;IAAiB,SAAS;IACvB,UAAA,QAAQ,KAAK,QAAQ,UAAU;KAC9B,MAAM,OAAO,OAAO;KACpB,OACE,oBAAC,OAAO,KAAR;MAEE,OAAO,EAAE,QAAQ,MAAM;MACvB,SAAS;OAAE,SAAS;OAAG,GAAG;OAAI,OAAO;MAAK;MAC1C,SAAS;OACP,SAAS,SAAS,IAAI,IAAI;OAC1B,GAAG,OAAO,OAAO;OACjB,GAAG,OAAO,OAAO;OACjB,OAAO,IAAI,OAAO;MACpB;MACA,MAAM;OAAE,SAAS;OAAG,GAAG;OAAI,OAAO;MAAK;MACvC,YAAY,QAAQ,UAAU;MAE9B,WAAU;MAEV,UAAA,oBAAC,MAAD;OACE,IAAI,OAAO;OACX,SAAS,OAAO;OAChB,QAAQ,OAAO;OACf,MAAM,OAAO;OACb,MAAM,QAAQ,UAAU;MACzB,CAAA;KACS,GArBL,OAAO,EAqBF;IAEhB,CAAC;GACc,CAAA;EACd,CAAA;CACK,GAxCN,MAwCM,CAEC,EAAA,CAAA,GACjB,SAAS,IACX;AACF"}

package/dist/recipes/thumb-picker/thumb-picker.d.ts

@@ -0,0 +1,31 @@
+import { Choice } from "./choice.js";
+import { TreeWalk } from "@kestack/use-gesture";
+//#region src/recipes/thumb-picker/thumb-picker.d.ts
+/**
+ * A Thumb Lock that picks from a tree of choices: the left thumb resting
+ * still while another finger swipes. The walk starts on the choice `start`
+ * names; nothing shows until the finger has gone `reveal` px, then the
+ * choices show over everything else, dimmed and blurred. Each `step` px
+ * the finger goes from where it last moved something makes one move. Up and down Step
+ * through a list; right opens the marked choice's own choices, starting
+ * on the one last marked there in this swipe, and left goes back. Lifting
+ * the finger chooses the marked choice, unless it is where the swipe began
+ * or on the way to it; lifting the thumb first chooses nothing. A Wrong
+ * Way shakes the menu. Each Lock, Step, opening, going back and Wrong Way
+ * is told, for sound
+ * and touch to follow.
+ */
+export declare function ThumbPicker(props: {
+  readonly tree: ReadonlyArray<Choice>;
+  /** The ids of the choices the swipe begins at, top to bottom. */
+  readonly start: ReadonlyArray<string>;
+  readonly onFeedback?: (feedback: 'lock' | TreeWalk.Event) => void;
+  readonly enabled?: boolean;
+  /** How far, in px, the finger goes before anything shows: 14 unless told. */
+  readonly reveal?: number;
+  /** How far, in px, the finger goes for each move: 30 unless told. */
+  readonly step?: number;
+}): import("react").JSX.Element;
+//#endregion
+export type { Choice };
+//# sourceMappingURL=thumb-picker.d.ts.map

package/dist/recipes/thumb-picker/thumb-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thumb-picker.d.ts","names":[],"sources":["../../../src/recipes/thumb-picker/thumb-picker.tsx"],"mappings":";;;;;;;;;;;;;;;;;wBAsBgB,YAAY;WACjB,MAAM,cAAc;;WAEpB,OAAO;WACP,cAAc,mBAAmB,SAAS;WAC1C;;WAEA;;WAEA;oBACV,IAAA"}

package/dist/recipes/thumb-picker/thumb-picker.js

@@ -0,0 +1,65 @@
+import { useThumbLock } from "./lock.js";
+import { Menu } from "./menu.js";
+import { useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { TreeWalk } from "@kestack/use-gesture";
+//#region src/recipes/thumb-picker/thumb-picker.tsx
+/**
+* A Thumb Lock that picks from a tree of choices: the left thumb resting
+* still while another finger swipes. The walk starts on the choice `start`
+* names; nothing shows until the finger has gone `reveal` px, then the
+* choices show over everything else, dimmed and blurred. Each `step` px
+* the finger goes from where it last moved something makes one move. Up and down Step
+* through a list; right opens the marked choice's own choices, starting
+* on the one last marked there in this swipe, and left goes back. Lifting
+* the finger chooses the marked choice, unless it is where the swipe began
+* or on the way to it; lifting the thumb first chooses nothing. A Wrong
+* Way shakes the menu. Each Lock, Step, opening, going back and Wrong Way
+* is told, for sound
+* and touch to follow.
+*/
+function ThumbPicker(props) {
+	const [walk, setWalk] = useState();
+	const [shakes, setShakes] = useState(0);
+	const walking = useRef(void 0);
+	const latest = useRef(props);
+	latest.current = props;
+	const show = (next) => {
+		walking.current = next;
+		setWalk(next);
+	};
+	useThumbLock({
+		enabled: props.enabled !== false,
+		onLock: () => {
+			const { tree, start, onFeedback } = latest.current;
+			show(TreeWalk.begin(tree, start));
+			onFeedback?.("lock");
+		},
+		onMove: (finger) => {
+			const { tree, start, onFeedback, reveal, step } = latest.current;
+			if (walking.current === void 0) return;
+			const after = TreeWalk.move(walking.current, tree, start, finger, {
+				reveal: reveal ?? TreeWalk.DISTANCES.reveal,
+				step: step ?? TreeWalk.DISTANCES.step
+			});
+			for (const event of after.events) onFeedback?.(event);
+			if (after.events.includes("wrong")) setShakes((count) => count + 1);
+			if (after.walk !== walking.current) show(after.walk);
+		},
+		onEnd: (lifted) => {
+			const last = walking.current;
+			show(void 0);
+			if (!lifted || last === void 0) return;
+			const { tree, start } = latest.current;
+			TreeWalk.chosen(last, tree, start)?.onSelect?.();
+		}
+	});
+	return /* @__PURE__ */ jsx(Menu, {
+		shakes,
+		columns: walk === void 0 || !walk.shown ? void 0 : TreeWalk.columns(walk, props.tree, props.start)
+	});
+}
+//#endregion
+export { ThumbPicker };
+
+//# sourceMappingURL=thumb-picker.js.map

package/dist/recipes/thumb-picker/thumb-picker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thumb-picker.js","names":[],"sources":["../../../src/recipes/thumb-picker/thumb-picker.tsx"],"sourcesContent":["import { TreeWalk } from '@kestack/use-gesture';\nimport { useRef, useState } from 'react';\nimport type { Choice } from './choice.ts';\nimport { useThumbLock } from './lock.ts';\nimport { Menu } from './menu.tsx';\n\nexport type { Choice } from './choice.ts';\n\n/**\n * A Thumb Lock that picks from a tree of choices: the left thumb resting\n * still while another finger swipes. The walk starts on the choice `start`\n * names; nothing shows until the finger has gone `reveal` px, then the\n * choices show over everything else, dimmed and blurred. Each `step` px\n * the finger goes from where it last moved something makes one move. Up and down Step\n * through a list; right opens the marked choice's own choices, starting\n * on the one last marked there in this swipe, and left goes back. Lifting\n * the finger chooses the marked choice, unless it is where the swipe began\n * or on the way to it; lifting the thumb first chooses nothing. A Wrong\n * Way shakes the menu. Each Lock, Step, opening, going back and Wrong Way\n * is told, for sound\n * and touch to follow.\n */\nexport function ThumbPicker(props: {\n  readonly tree: ReadonlyArray<Choice>;\n  /** The ids of the choices the swipe begins at, top to bottom. */\n  readonly start: ReadonlyArray<string>;\n  readonly onFeedback?: (feedback: 'lock' | TreeWalk.Event) => void;\n  readonly enabled?: boolean;\n  /** How far, in px, the finger goes before anything shows: 14 unless told. */\n  readonly reveal?: number;\n  /** How far, in px, the finger goes for each move: 30 unless told. */\n  readonly step?: number;\n}) {\n  const [walk, setWalk] = useState<TreeWalk.Walk>();\n  // How many Wrong Ways the menu has shaken for.\n  const [shakes, setShakes] = useState(0);\n  // The walk as the finger left it, ahead of the next render.\n  const walking = useRef<TreeWalk.Walk>(undefined);\n  const latest = useRef(props);\n  latest.current = props;\n\n  const show = (next: TreeWalk.Walk | undefined) => {\n    walking.current = next;\n    setWalk(next);\n  };\n\n  useThumbLock({\n    enabled: props.enabled !== false,\n    onLock: () => {\n      const { tree, start, onFeedback } = latest.current;\n      show(TreeWalk.begin(tree, start));\n      onFeedback?.('lock');\n    },\n    onMove: (finger) => {\n      const { tree, start, onFeedback, reveal, step } = latest.current;\n      if (walking.current === undefined) return;\n      const after = TreeWalk.move(walking.current, tree, start, finger, {\n        reveal: reveal ?? TreeWalk.DISTANCES.reveal,\n        step: step ?? TreeWalk.DISTANCES.step,\n      });\n      for (const event of after.events) onFeedback?.(event);\n      if (after.events.includes('wrong')) setShakes((count) => count + 1);\n      if (after.walk !== walking.current) show(after.walk);\n    },\n    onEnd: (lifted) => {\n      const last = walking.current;\n      show(undefined);\n      if (!lifted || last === undefined) return;\n      const { tree, start } = latest.current;\n      TreeWalk.chosen(last, tree, start)?.onSelect?.();\n    },\n  });\n\n  return (\n    <Menu\n      shakes={shakes}\n      columns={\n        walk === undefined || !walk.shown\n          ? undefined\n          : TreeWalk.columns(walk, props.tree, props.start)\n      }\n    />\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,YAAY,OAUzB;CACD,MAAM,CAAC,MAAM,WAAW,SAAwB;CAEhD,MAAM,CAAC,QAAQ,aAAa,SAAS,CAAC;CAEtC,MAAM,UAAU,OAAsB,KAAA,CAAS;CAC/C,MAAM,SAAS,OAAO,KAAK;CAC3B,OAAO,UAAU;CAEjB,MAAM,QAAQ,SAAoC;EAChD,QAAQ,UAAU;EAClB,QAAQ,IAAI;CACd;CAEA,aAAa;EACX,SAAS,MAAM,YAAY;EAC3B,cAAc;GACZ,MAAM,EAAE,MAAM,OAAO,eAAe,OAAO;GAC3C,KAAK,SAAS,MAAM,MAAM,KAAK,CAAC;GAChC,aAAa,MAAM;EACrB;EACA,SAAS,WAAW;GAClB,MAAM,EAAE,MAAM,OAAO,YAAY,QAAQ,SAAS,OAAO;GACzD,IAAI,QAAQ,YAAY,KAAA,GAAW;GACnC,MAAM,QAAQ,SAAS,KAAK,QAAQ,SAAS,MAAM,OAAO,QAAQ;IAChE,QAAQ,UAAU,SAAS,UAAU;IACrC,MAAM,QAAQ,SAAS,UAAU;GACnC,CAAC;GACD,KAAK,MAAM,SAAS,MAAM,QAAQ,aAAa,KAAK;GACpD,IAAI,MAAM,OAAO,SAAS,OAAO,GAAG,WAAW,UAAU,QAAQ,CAAC;GAClE,IAAI,MAAM,SAAS,QAAQ,SAAS,KAAK,MAAM,IAAI;EACrD;EACA,QAAQ,WAAW;GACjB,MAAM,OAAO,QAAQ;GACrB,KAAK,KAAA,CAAS;GACd,IAAI,CAAC,UAAU,SAAS,KAAA,GAAW;GACnC,MAAM,EAAE,MAAM,UAAU,OAAO;GAC/B,SAAS,OAAO,MAAM,MAAM,KAAK,CAAC,EAAE,WAAW;EACjD;CACF,CAAC;CAED,OACE,oBAAC,MAAD;EACU;EACR,SACE,SAAS,KAAA,KAAa,CAAC,KAAK,QACxB,KAAA,IACA,SAAS,QAAQ,MAAM,MAAM,MAAM,MAAM,KAAK;CAErD,CAAA;AAEL"}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+import { CloudBackend, LiveNamespace, ServerConfig, createServer } from "./serve/serve.js";
+import "./serve/index.js";
+import { LiveAuth, LiveBackend, LiveObject, liveObject } from "./live/live.js";
+import "./live/index.js";
+import { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage } from "./stage/stage.js";
+import { Handle, webServer } from "./worker/worker.js";
+export { type CloudBackend, type Handle, type LiveAuth, type LiveBackend, type LiveNamespace, type LiveObject, type ServerConfig, assertStageIsSafe, createServer, devConfigFor, domainFor, isDeployedStage, liveObject, webServer };

package/dist/server/index.js

@@ -0,0 +1,5 @@
+import { liveObject } from "./live/live.js";
+import { webServer } from "./worker/worker.js";
+import { createServer } from "./serve/serve.js";
+import { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage } from "./stage/stage.js";
+export { assertStageIsSafe, createServer, devConfigFor, domainFor, isDeployedStage, liveObject, webServer };

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

@@ -0,0 +1,2 @@
+import { LiveAuth, LiveBackend, LiveObject, forOwner, liveObject, liveUser, ownedBy } from "./live.js";
+export { type LiveAuth, type LiveBackend, type LiveObject, forOwner, liveObject, liveUser, ownedBy };

package/dist/server/live/index.js

@@ -0,0 +1,2 @@
+import { forOwner, liveObject, liveUser, ownedBy } from "./live.js";
+export { forOwner, liveObject, liveUser, ownedBy };

package/dist/server/live/live.d.ts

@@ -0,0 +1,56 @@
+import { Api } from "../../app/apis/apis.js";
+import "../../define/index.js";
+import { Context, Layer } from "effect";
+import { Rpc } from "@kestack/rpc-toolkit/rpc";
+import { Rpc as Rpc$1 } from "effect/rpc";
+import { Authz } from "@kestack/auth-toolkit/guard";
+import * as cf from "@cloudflare/workers-types";
+//#region src/server/live/live.d.ts
+/** The shared sign-in service, as a cloud API checks each call with it. */
+export interface LiveAuth {
+  readonly url: string;
+  readonly resource?: string | undefined;
+}
+/** One API's handlers in a Live Object, with the services they stand on
+ * given: made once each time the object wakes, from its own storage. */
+export type LiveBackend<Rpcs extends Rpc$1.Any> = Layer.Layer<Rpc$1.ToHandler<Rpcs> | Rpc$1.Middleware<Rpcs>, unknown, any>;
+/**
+ * Who a WebSocket opening at the cloud is for: the token in its address, as
+ * a browser sets no headers on one, checked as a call's would be. Null
+ * when it names nobody; `unavailable` when the sign-in service could not
+ * be asked.
+ */
+export declare const liveUser: (request: Request, auth: LiveAuth) => Promise<string | null | 'unavailable'>;
+/** The header `createServer` names a Live Object's owner by, set on every
+ * request it forwards there, whatever the caller sent. */
+export declare const LIVE_OWNER = "x-kstack-live-owner";
+/** `request` as forwarded to the Live Object of `owner`. */
+export declare const forOwner: (request: Request, owner: string) => Request;
+type Resolver = Context.Service.Identifier<typeof Authz.Resolver>;
+/** `found`, narrowed to calls signed by `owner`: any other user's is
+ * signed by nobody. */
+export declare const ownedBy: (owner: () => Promise<string | undefined>) => Layer.Layer<Resolver, never, Resolver>;
+/** What the runtime calls on a Live Object. */
+export interface LiveObject {
+  fetch(request: Request): Promise<Response>;
+  webSocketMessage(ws: cf.WebSocket, data: string | ArrayBuffer): Promise<void>;
+  webSocketClose(ws: cf.WebSocket, code: number, reason: string): Promise<void>;
+}
+/**
+ * A Live Object: a Durable Object class serving one API over hibernatable
+ * WebSockets, one object per user, its storage theirs alone. It keeps whom
+ * it was first opened for, and refuses a socket opened for anyone else;
+ * every call is still checked, by the token it carries, and refused unless
+ * that token is the same user's. `backend` makes the API's
+ * handlers from the object's own storage, and `streams` where open streams
+ * are kept while it sleeps (in the sockets' own notes, about 2 KB each,
+ * when not given). Export it from the Worker by the name its binding has.
+ */
+export declare const liveObject: <Rpcs extends Rpc$1.Any, Env>(options: {
+  readonly api: Api<Rpcs>;
+  readonly backend: (env: Env, storage: cf.DurableObjectStorage) => LiveBackend<Rpcs>;
+  readonly auth: LiveAuth;
+  readonly streams?: (state: cf.DurableObjectState) => Rpc.StreamStore;
+}) => new (state: cf.DurableObjectState, env: Env) => LiveObject;
+//#endregion
+//# sourceMappingURL=live.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","names":["EffectRpc"],"sources":["../../../src/server/live/live.ts"],"mappings":";;;;;;;;;iBAUiB;WACN;WACA;;;;YAKC,YAAY,aAAaA,MAAU,OAAO,MAAM,MAC1DA,MAAU,UAAU,QAAQA,MAAU,WAAW;;;;;;;qBAmCtC,WAAQ,SACV,SAAO,MACV,aACL;;;qBAiBU;;qBAGA,WAAQ,SAAa,SAAO,kBAAkB;KAMtD,WAAW,QAAQ,QAAQ,kBAAkB,MAAM;;;qBAO3C,UAAO,aACL,gCACZ,MAAM,MAAM,iBAAiB;;iBAkBf;EACf,MAAM,SAAS,UAAU,QAAQ;EACjC,iBAAiB,IAAI,GAAG,WAAW,eAAe,cAAc;EAChE,eAAe,IAAI,GAAG,WAAW,cAAc,iBAAiB;;;;;;;;;;;;qBAarD,aAAc,aAAaA,MAAU,KAAK,KAAG;WAC/C,KAAK,IAAI;WACT,UACP,KAAK,KACL,SAAS,GAAG,yBACT,YAAY;WACR,MAAM;WACN,WAAW,OAAO,GAAG,uBAAuB,IAAI;WAClD,OAAO,GAAG,oBAAoB,KAAK,QAAQ"}

package/dist/server/live/live.js

@@ -0,0 +1,98 @@
+import { Effect, Layer } from "effect";
+import { Rpc } from "@kestack/rpc-toolkit/rpc";
+import { Authz } from "@kestack/auth-toolkit/guard";
+import { authz } from "@kestack/auth-toolkit/server/cloud";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+//#region src/server/live/live.ts
+const resolver = (auth) => authz.cloud({
+	authWorkerUrl: auth.url,
+	...auth.resource !== void 0 && { resource: auth.resource }
+});
+const toWeb = (response) => {
+	const { body } = response;
+	return body._tag === "Raw" && body.body instanceof Response ? body.body : HttpServerResponse.toWeb(response);
+};
+const socketOf = (ws) => ({
+	ws,
+	close: (code, reason) => Effect.sync(() => ws.close(code, reason)),
+	serializeAttachment: (value) => ws.serializeAttachment(value),
+	deserializeAttachment: () => ws.deserializeAttachment()
+});
+/**
+* Who a WebSocket opening at the cloud is for: the token in its address, as
+* a browser sets no headers on one, checked as a call's would be. Null
+* when it names nobody; `unavailable` when the sign-in service could not
+* be asked.
+*/
+const liveUser = (request, auth) => {
+	const token = new URL(request.url).searchParams.get("access_token");
+	if (token === null) return Promise.resolve(null);
+	const signed = new Request(request.url, { headers: { authorization: `Bearer ${token}` } });
+	return Effect.runPromise(Authz.Resolver.use((found) => found.resolve(signed)).pipe(Effect.map((resolution) => resolution?.current.user.id ?? null), Effect.catch(() => Effect.succeed("unavailable")), Effect.provide(resolver(auth))));
+};
+/** The header `createServer` names a Live Object's owner by, set on every
+* request it forwards there, whatever the caller sent. */
+const LIVE_OWNER = "x-kstack-live-owner";
+/** `request` as forwarded to the Live Object of `owner`. */
+const forOwner = (request, owner) => {
+	const headers = new Headers(request.headers);
+	headers.set(LIVE_OWNER, owner);
+	return new Request(request, { headers });
+};
+const OWNER_KEY = "@kestack/web-platform/live/owner";
+/** `found`, narrowed to calls signed by `owner`: any other user's is
+* signed by nobody. */
+const ownedBy = (owner) => Layer.effect(Authz.Resolver, Effect.map(Authz.Resolver, (found) => Authz.Resolver.of({ resolve: (request) => Effect.flatMap(found.resolve(request), (resolution) => resolution === null ? Effect.succeed(null) : Effect.map(Effect.promise(owner), (pinned) => pinned === resolution.current.user.id ? resolution : null)) })));
+/**
+* A Live Object: a Durable Object class serving one API over hibernatable
+* WebSockets, one object per user, its storage theirs alone. It keeps whom
+* it was first opened for, and refuses a socket opened for anyone else;
+* every call is still checked, by the token it carries, and refused unless
+* that token is the same user's. `backend` makes the API's
+* handlers from the object's own storage, and `streams` where open streams
+* are kept while it sleeps (in the sockets' own notes, about 2 KB each,
+* when not given). Export it from the Worker by the name its binding has.
+*/
+const liveObject = (options) => class {
+	#served;
+	#storage;
+	#owner;
+	constructor(state, env) {
+		this.#storage = state.storage;
+		const { state: hibernation, upgrade } = Rpc.websocket.fromDurableObjectState(state);
+		const handlers = options.backend(env, state.storage).pipe(Layer.provide(ownedBy(this.#pinned).pipe(Layer.provide(resolver(options.auth)))));
+		this.#served = Effect.runPromise(Effect.gen(function* () {
+			const rpc = yield* Rpc.websocket.server(options.api.group, handlers, {
+				state: hibernation,
+				upgrade,
+				...options.streams !== void 0 && { streams: options.streams(state) }
+			});
+			return {
+				accept: (request) => Effect.runPromise(rpc.accept.pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)), Effect.map(toWeb))),
+				message: (ws, data) => Effect.runPromise(rpc.message(socketOf(ws), data)),
+				close: (ws, code, reason) => Effect.runPromise(rpc.close(socketOf(ws), code, reason))
+			};
+		}));
+	}
+	#pinned = () => this.#owner ??= this.#storage.get(OWNER_KEY);
+	async fetch(request) {
+		const owner = request.headers.get(LIVE_OWNER);
+		if (owner === null) return new Response("Forbidden", { status: 403 });
+		const pinned = await this.#pinned();
+		if (pinned === void 0) {
+			await this.#storage.put(OWNER_KEY, owner);
+			this.#owner = Promise.resolve(owner);
+		} else if (pinned !== owner) return new Response("Forbidden", { status: 403 });
+		return (await this.#served).accept(request);
+	}
+	async webSocketMessage(ws, data) {
+		await (await this.#served).message(ws, data);
+	}
+	async webSocketClose(ws, code, reason) {
+		await (await this.#served).close(ws, code, reason);
+	}
+};
+//#endregion
+export { LIVE_OWNER, forOwner, liveObject, liveUser, ownedBy };
+
+//# sourceMappingURL=live.js.map

package/dist/server/live/live.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.js","names":[],"sources":["../../../src/server/live/live.ts"],"sourcesContent":["import type * as cf from '@cloudflare/workers-types';\nimport { Context, Effect, Layer } from 'effect';\nimport { HttpServerRequest, HttpServerResponse } from 'effect/http';\nimport type { Rpc as EffectRpc } from 'effect/rpc';\nimport type { Api } from '../../define/index.ts';\nimport { authz } from '@kestack/auth-toolkit/server/cloud';\nimport { Authz } from '@kestack/auth-toolkit/guard';\nimport { Rpc } from '@kestack/rpc-toolkit/rpc';\n\n/** The shared sign-in service, as a cloud API checks each call with it. */\nexport interface LiveAuth {\n  readonly url: string;\n  readonly resource?: string | undefined;\n}\n\n/** One API's handlers in a Live Object, with the services they stand on\n * given: made once each time the object wakes, from its own storage. */\nexport type LiveBackend<Rpcs extends EffectRpc.Any> = Layer.Layer<\n  EffectRpc.ToHandler<Rpcs> | EffectRpc.Middleware<Rpcs>,\n  unknown,\n  // oxlint-disable-next-line no-explicit-any\n  any\n>;\n\nconst resolver = (auth: LiveAuth) =>\n  authz.cloud({\n    authWorkerUrl: auth.url,\n    ...(auth.resource !== undefined && { resource: auth.resource }),\n  });\n\n// An Effect response as the runtime sends it: an upgrade is the raw\n// Response carrying its socket, which converting would lose.\nconst toWeb = (response: HttpServerResponse.HttpServerResponse): Response => {\n  const { body } = response;\n  return body._tag === 'Raw' && body.body instanceof Response\n    ? body.body\n    : HttpServerResponse.toWeb(response);\n};\n\n// A socket the runtime hands the object, as the RPC server reads it.\nconst socketOf = (ws: cf.WebSocket): Rpc.websocket.HibernatingSocket => ({\n  ws,\n  close: (code, reason) => Effect.sync(() => ws.close(code, reason)),\n  serializeAttachment: (value) => ws.serializeAttachment(value),\n  deserializeAttachment: <T>() => ws.deserializeAttachment() as T | null,\n});\n\n/**\n * Who a WebSocket opening at the cloud is for: the token in its address, as\n * a browser sets no headers on one, checked as a call's would be. Null\n * when it names nobody; `unavailable` when the sign-in service could not\n * be asked.\n */\nexport const liveUser = (\n  request: Request,\n  auth: LiveAuth,\n): Promise<string | null | 'unavailable'> => {\n  const token = new URL(request.url).searchParams.get('access_token');\n  if (token === null) return Promise.resolve(null);\n  const signed = new Request(request.url, {\n    headers: { authorization: `Bearer ${token}` },\n  });\n  return Effect.runPromise(\n    Authz.Resolver.use((found) => found.resolve(signed)).pipe(\n      Effect.map((resolution) => resolution?.current.user.id ?? null),\n      Effect.catch(() => Effect.succeed('unavailable' as const)),\n      Effect.provide(resolver(auth)),\n    ),\n  );\n};\n\n/** The header `createServer` names a Live Object's owner by, set on every\n * request it forwards there, whatever the caller sent. */\nexport const LIVE_OWNER = 'x-kstack-live-owner';\n\n/** `request` as forwarded to the Live Object of `owner`. */\nexport const forOwner = (request: Request, owner: string): Request => {\n  const headers = new Headers(request.headers);\n  headers.set(LIVE_OWNER, owner);\n  return new Request(request, { headers });\n};\n\ntype Resolver = Context.Service.Identifier<typeof Authz.Resolver>;\n\n// Where the object keeps whom it was opened for, beside the app's own keys.\nconst OWNER_KEY = '@kestack/web-platform/live/owner';\n\n/** `found`, narrowed to calls signed by `owner`: any other user's is\n * signed by nobody. */\nexport const ownedBy = (\n  owner: () => Promise<string | undefined>,\n): Layer.Layer<Resolver, never, Resolver> =>\n  Layer.effect(\n    Authz.Resolver,\n    Effect.map(Authz.Resolver, (found) =>\n      Authz.Resolver.of({\n        resolve: (request) =>\n          Effect.flatMap(found.resolve(request), (resolution) =>\n            resolution === null\n              ? Effect.succeed(null)\n              : Effect.map(Effect.promise(owner), (pinned) =>\n                  pinned === resolution.current.user.id ? resolution : null,\n                ),\n          ),\n      }),\n    ),\n  );\n\n/** What the runtime calls on a Live Object. */\nexport interface LiveObject {\n  fetch(request: Request): Promise<Response>;\n  webSocketMessage(ws: cf.WebSocket, data: string | ArrayBuffer): Promise<void>;\n  webSocketClose(ws: cf.WebSocket, code: number, reason: string): Promise<void>;\n}\n\n/**\n * A Live Object: a Durable Object class serving one API over hibernatable\n * WebSockets, one object per user, its storage theirs alone. It keeps whom\n * it was first opened for, and refuses a socket opened for anyone else;\n * every call is still checked, by the token it carries, and refused unless\n * that token is the same user's. `backend` makes the API's\n * handlers from the object's own storage, and `streams` where open streams\n * are kept while it sleeps (in the sockets' own notes, about 2 KB each,\n * when not given). Export it from the Worker by the name its binding has.\n */\nexport const liveObject = <Rpcs extends EffectRpc.Any, Env>(options: {\n  readonly api: Api<Rpcs>;\n  readonly backend: (\n    env: Env,\n    storage: cf.DurableObjectStorage,\n  ) => LiveBackend<Rpcs>;\n  readonly auth: LiveAuth;\n  readonly streams?: (state: cf.DurableObjectState) => Rpc.StreamStore;\n}): new (state: cf.DurableObjectState, env: Env) => LiveObject =>\n  class implements LiveObject {\n    readonly #served: Promise<{\n      readonly accept: (request: Request) => Promise<Response>;\n      readonly message: (\n        socket: cf.WebSocket,\n        data: string | ArrayBuffer,\n      ) => Promise<void>;\n      readonly close: (\n        socket: cf.WebSocket,\n        code: number,\n        reason: string,\n      ) => Promise<void>;\n    }>;\n\n    readonly #storage: cf.DurableObjectStorage;\n    #owner: Promise<string | undefined> | undefined;\n\n    constructor(state: cf.DurableObjectState, env: Env) {\n      this.#storage = state.storage;\n      const { state: hibernation, upgrade } =\n        Rpc.websocket.fromDurableObjectState(state);\n      const handlers = options\n        .backend(env, state.storage)\n        .pipe(\n          Layer.provide(\n            ownedBy(this.#pinned).pipe(Layer.provide(resolver(options.auth))),\n          ),\n        ) as Layer.Layer<\n        | EffectRpc.ToHandler<Rpcs>\n        | EffectRpc.Middleware<Rpcs>\n        | EffectRpc.ServicesServer<Rpcs>\n      >;\n      this.#served = Effect.runPromise(\n        Effect.gen(function* () {\n          const rpc = yield* Rpc.websocket.server(options.api.group, handlers, {\n            state: hibernation,\n            upgrade,\n            ...(options.streams !== undefined && {\n              streams: options.streams(state),\n            }),\n          });\n          return {\n            accept: (request: Request) =>\n              Effect.runPromise(\n                rpc.accept.pipe(\n                  Effect.provideService(\n                    HttpServerRequest.HttpServerRequest,\n                    HttpServerRequest.fromWeb(request),\n                  ),\n                  Effect.map(toWeb),\n                ),\n              ),\n            message: (ws: cf.WebSocket, data: string | ArrayBuffer) =>\n              Effect.runPromise(rpc.message(socketOf(ws), data)),\n            close: (ws: cf.WebSocket, code: number, reason: string) =>\n              Effect.runPromise(rpc.close(socketOf(ws), code, reason)),\n          };\n        }),\n      );\n    }\n\n    // Whom the object was first opened for, read once per wake.\n    readonly #pinned = () =>\n      (this.#owner ??= this.#storage.get<string>(OWNER_KEY));\n\n    async fetch(request: Request): Promise<Response> {\n      const owner = request.headers.get(LIVE_OWNER);\n      if (owner === null) return new Response('Forbidden', { status: 403 });\n      const pinned = await this.#pinned();\n      if (pinned === undefined) {\n        await this.#storage.put(OWNER_KEY, owner);\n        this.#owner = Promise.resolve(owner);\n      } else if (pinned !== owner)\n        return new Response('Forbidden', { status: 403 });\n      return (await this.#served).accept(request);\n    }\n\n    async webSocketMessage(ws: cf.WebSocket, data: string | ArrayBuffer) {\n      await (await this.#served).message(ws, data);\n    }\n\n    async webSocketClose(ws: cf.WebSocket, code: number, reason: string) {\n      await (await this.#served).close(ws, code, reason);\n    }\n  };\n"],"mappings":";;;;;;AAwBA,MAAM,YAAY,SAChB,MAAM,MAAM;CACV,eAAe,KAAK;CACpB,GAAI,KAAK,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;AAC/D,CAAC;AAIH,MAAM,SAAS,aAA8D;CAC3E,MAAM,EAAE,SAAS;CACjB,OAAO,KAAK,SAAS,SAAS,KAAK,gBAAgB,WAC/C,KAAK,OACL,mBAAmB,MAAM,QAAQ;AACvC;AAGA,MAAM,YAAY,QAAuD;CACvE;CACA,QAAQ,MAAM,WAAW,OAAO,WAAW,GAAG,MAAM,MAAM,MAAM,CAAC;CACjE,sBAAsB,UAAU,GAAG,oBAAoB,KAAK;CAC5D,6BAAgC,GAAG,sBAAsB;AAC3D;;;;;;;AAQA,MAAa,YACX,SACA,SAC2C;CAC3C,MAAM,QAAQ,IAAI,IAAI,QAAQ,GAAG,CAAC,CAAC,aAAa,IAAI,cAAc;CAClE,IAAI,UAAU,MAAM,OAAO,QAAQ,QAAQ,IAAI;CAC/C,MAAM,SAAS,IAAI,QAAQ,QAAQ,KAAK,EACtC,SAAS,EAAE,eAAe,UAAU,QAAQ,EAC9C,CAAC;CACD,OAAO,OAAO,WACZ,MAAM,SAAS,KAAK,UAAU,MAAM,QAAQ,MAAM,CAAC,CAAC,CAAC,KACnD,OAAO,KAAK,eAAe,YAAY,QAAQ,KAAK,MAAM,IAAI,GAC9D,OAAO,YAAY,OAAO,QAAQ,aAAsB,CAAC,GACzD,OAAO,QAAQ,SAAS,IAAI,CAAC,CAC/B,CACF;AACF;;;AAIA,MAAa,aAAa;;AAG1B,MAAa,YAAY,SAAkB,UAA2B;CACpE,MAAM,UAAU,IAAI,QAAQ,QAAQ,OAAO;CAC3C,QAAQ,IAAI,YAAY,KAAK;CAC7B,OAAO,IAAI,QAAQ,SAAS,EAAE,QAAQ,CAAC;AACzC;AAKA,MAAM,YAAY;;;AAIlB,MAAa,WACX,UAEA,MAAM,OACJ,MAAM,UACN,OAAO,IAAI,MAAM,WAAW,UAC1B,MAAM,SAAS,GAAG,EAChB,UAAU,YACR,OAAO,QAAQ,MAAM,QAAQ,OAAO,IAAI,eACtC,eAAe,OACX,OAAO,QAAQ,IAAI,IACnB,OAAO,IAAI,OAAO,QAAQ,KAAK,IAAI,WACjC,WAAW,WAAW,QAAQ,KAAK,KAAK,aAAa,IACvD,CACN,EACJ,CAAC,CACH,CACF;;;;;;;;;;;AAmBF,MAAa,cAA+C,YAS1D,MAA4B;CAC1B;CAaA;CACA;CAEA,YAAY,OAA8B,KAAU;EAClD,KAAK,WAAW,MAAM;EACtB,MAAM,EAAE,OAAO,aAAa,YAC1B,IAAI,UAAU,uBAAuB,KAAK;EAC5C,MAAM,WAAW,QACd,QAAQ,KAAK,MAAM,OAAO,CAAC,CAC3B,KACC,MAAM,QACJ,QAAQ,KAAK,OAAO,CAAC,CAAC,KAAK,MAAM,QAAQ,SAAS,QAAQ,IAAI,CAAC,CAAC,CAClE,CACF;EAKF,KAAK,UAAU,OAAO,WACpB,OAAO,IAAI,aAAa;GACtB,MAAM,MAAM,OAAO,IAAI,UAAU,OAAO,QAAQ,IAAI,OAAO,UAAU;IACnE,OAAO;IACP;IACA,GAAI,QAAQ,YAAY,KAAA,KAAa,EACnC,SAAS,QAAQ,QAAQ,KAAK,EAChC;GACF,CAAC;GACD,OAAO;IACL,SAAS,YACP,OAAO,WACL,IAAI,OAAO,KACT,OAAO,eACL,kBAAkB,mBAClB,kBAAkB,QAAQ,OAAO,CACnC,GACA,OAAO,IAAI,KAAK,CAClB,CACF;IACF,UAAU,IAAkB,SAC1B,OAAO,WAAW,IAAI,QAAQ,SAAS,EAAE,GAAG,IAAI,CAAC;IACnD,QAAQ,IAAkB,MAAc,WACtC,OAAO,WAAW,IAAI,MAAM,SAAS,EAAE,GAAG,MAAM,MAAM,CAAC;GAC3D;EACF,CAAC,CACH;CACF;CAGA,gBACG,KAAK,WAAW,KAAK,SAAS,IAAY,SAAS;CAEtD,MAAM,MAAM,SAAqC;EAC/C,MAAM,QAAQ,QAAQ,QAAQ,IAAI,UAAU;EAC5C,IAAI,UAAU,MAAM,OAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC;EACpE,MAAM,SAAS,MAAM,KAAK,QAAQ;EAClC,IAAI,WAAW,KAAA,GAAW;GACxB,MAAM,KAAK,SAAS,IAAI,WAAW,KAAK;GACxC,KAAK,SAAS,QAAQ,QAAQ,KAAK;EACrC,OAAO,IAAI,WAAW,OACpB,OAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC;EAClD,QAAQ,MAAM,KAAK,QAAA,CAAS,OAAO,OAAO;CAC5C;CAEA,MAAM,iBAAiB,IAAkB,MAA4B;EACnE,OAAO,MAAM,KAAK,QAAA,CAAS,QAAQ,IAAI,IAAI;CAC7C;CAEA,MAAM,eAAe,IAAkB,MAAc,QAAgB;EACnE,OAAO,MAAM,KAAK,QAAA,CAAS,MAAM,IAAI,MAAM,MAAM;CACnD;AACF"}

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

@@ -0,0 +1,2 @@
+import { CloudBackend, LiveNamespace, ServerConfig, createServer } from "./serve.js";
+export { type CloudBackend, type LiveNamespace, type ServerConfig, createServer };

package/dist/server/serve/index.js

@@ -0,0 +1,2 @@
+import { createServer } from "./serve.js";
+export { createServer };

package/dist/server/serve/serve.d.ts

@@ -0,0 +1,48 @@
+import { Apis, RpcsOf } from "../../app/apis/apis.js";
+import "../../define/index.js";
+import { Layer } from "effect";
+import { Rpc } from "effect/rpc";
+//#region src/server/serve/serve.d.ts
+/** One API's handlers on the cloud Backend, with the services they stand
+ * on given; who signed a call is given by `createServer` when the app has
+ * auth. */
+export type CloudBackend<Rpcs extends Rpc.Any> = Layer.Layer<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>, unknown, any>;
+/** Where a Worker reaches its Live Objects, one per name: a Durable
+ * Object namespace binding. */
+export interface LiveNamespace {
+  readonly getByName: (name: string) => {
+    readonly fetch: (request: Request) => Promise<Response>;
+  };
+}
+export interface ServerConfig<A extends Apis, Env> {
+  /** The app's APIs, as its client names them. Each served here is at a
+   * path: an `http` API by `backend`, a `websocket` one by the caller's own
+   * Live Object in `live`. One at a full URL is served elsewhere. */
+  readonly apis: A;
+  /** Every `http` API's handlers on the cloud Backend, made for one request
+   * from the platform's own context, such as a Worker's `env`. */
+  readonly backend?: (env: Env) => { readonly [K in keyof A]?: CloudBackend<RpcsOf<A[K]>>; };
+  /** Every `websocket` API's Live Objects, from the Worker's `env`. A socket
+   * opens at the object named for whoever its token names, so needs `auth`. */
+  readonly live?: (env: Env) => { readonly [K in keyof A]?: LiveNamespace; };
+  /** The shared sign-in service, for an app with auth: each call is
+   * checked for the Account its token or cookie names, and the sign-in
+   * cookies refreshed while checking go back on the answer. `resource` is
+   * the audience an Access Token must be for, as a phone's is. */
+  readonly auth?: {
+    readonly url: string;
+    readonly resource?: string | undefined;
+  };
+}
+/**
+ * A web app's server: each of its `http` APIs at its path, on the cloud
+ * Backend, each `websocket` one at its path in the caller's own Live
+ * Object, and everything else the app's pages, from TanStack Start. A
+ * plain fetch handler, so it is a Cloudflare Worker's default export as it
+ * is.
+ */
+export declare const createServer: <A extends Apis, Env>(config: ServerConfig<A, Env>) => {
+  fetch: (request: Request, env: Env) => Promise<Response>;
+};
+//#endregion
+//# sourceMappingURL=serve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","names":["EffectRpc"],"sources":["../../../src/server/serve/serve.ts"],"mappings":";;;;;;;;YAWY,aAAa,aAAaA,IAAU,OAAO,MAAM,MAC3DA,IAAU,UAAU,QAAQA,IAAU,WAAW;;;iBAQlC;WACN,YAAY;aACV,QAAQ,SAAS,YAAY,QAAQ;;;iBAIjC,aAAa,UAAU,MAAM;;;;WAInC,MAAM;;;WAGN,WAAW,KAAK,oBACb,WAAW,KAAK,aAAa,OAAO,EAAE;;;WAIzC,QAAQ,KAAK,oBAAoB,WAAW,KAAK;;;;;WAKjD;aACE;aACA;;;;;;;;;;qBAcA,eAAgB,UAAU,MAAM,KAAG,QACtC,aAAa,GAAG"}

package/dist/server/serve/serve.js

@@ -0,0 +1,47 @@
+import { forOwner, liveUser } from "../live/live.js";
+import { webServer } from "../worker/worker.js";
+import { Layer } from "effect";
+import { Rpc } from "@kestack/rpc-toolkit/rpc";
+import { authz } from "@kestack/auth-toolkit/server/cloud";
+//#region src/server/serve/serve.ts
+const isUrl = (path) => /^[a-z][a-z0-9+.-]*:\/\//i.test(path);
+const normal = (path) => `/${path.replace(/^\/+|\/+$/g, "")}`;
+/**
+* A web app's server: each of its `http` APIs at its path, on the cloud
+* Backend, each `websocket` one at its path in the caller's own Live
+* Object, and everything else the app's pages, from TanStack Start. A
+* plain fetch handler, so it is a Cloudflare Worker's default export as it
+* is.
+*/
+const createServer = (config) => {
+	const served = Object.entries(config.apis).filter(([, api]) => !isUrl(api.path));
+	const { auth } = config;
+	const openLive = async (request, objects) => {
+		if (auth === void 0) return new Response("A Live Object needs auth", { status: 500 });
+		const user = await liveUser(request, auth);
+		if (user === null) return new Response("Unauthorized", { status: 401 });
+		if (user === "unavailable") return new Response("The sign-in service could not be asked", { status: 503 });
+		return objects.getByName(user).fetch(forOwner(request, user));
+	};
+	return webServer({ route: (request, env) => {
+		const path = normal(new URL(request.url).pathname);
+		const found = served.find(([, api]) => normal(api.path) === path);
+		if (found === void 0) return null;
+		const [name, api] = found;
+		if (api.transport === "websocket") {
+			const objects = config.live?.(env)[name];
+			return objects === void 0 ? Promise.resolve(new Response("Not found", { status: 404 })) : openLive(request, objects);
+		}
+		const handlers = config.backend?.(env)[name];
+		if (handlers === void 0) return Promise.resolve(new Response("Not found", { status: 404 }));
+		const layer = auth === void 0 ? handlers : handlers.pipe(Layer.provide(authz.cloud({
+			authWorkerUrl: auth.url,
+			...auth.resource !== void 0 && { resource: auth.resource }
+		})));
+		return Rpc.http.server(api.group, layer, ...auth === void 0 ? [] : [{ wrap: authz.cookies }])(request);
+	} });
+};
+//#endregion
+export { createServer };
+
+//# sourceMappingURL=serve.js.map

package/dist/server/serve/serve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.js","names":[],"sources":["../../../src/server/serve/serve.ts"],"sourcesContent":["import { Layer } from 'effect';\nimport type { Apis, RpcsOf } from '../../define/index.ts';\nimport type { Rpc as EffectRpc } from 'effect/rpc';\nimport { authz } from '@kestack/auth-toolkit/server/cloud';\nimport { Rpc } from '@kestack/rpc-toolkit/rpc';\nimport { forOwner, liveUser } from '../live/index.ts';\nimport { webServer } from '../worker/index.ts';\n\n/** One API's handlers on the cloud Backend, with the services they stand\n * on given; who signed a call is given by `createServer` when the app has\n * auth. */\nexport type CloudBackend<Rpcs extends EffectRpc.Any> = Layer.Layer<\n  EffectRpc.ToHandler<Rpcs> | EffectRpc.Middleware<Rpcs>,\n  unknown,\n  // oxlint-disable-next-line no-explicit-any\n  any\n>;\n\n/** Where a Worker reaches its Live Objects, one per name: a Durable\n * Object namespace binding. */\nexport interface LiveNamespace {\n  readonly getByName: (name: string) => {\n    readonly fetch: (request: Request) => Promise<Response>;\n  };\n}\n\nexport interface ServerConfig<A extends Apis, Env> {\n  /** The app's APIs, as its client names them. Each served here is at a\n   * path: an `http` API by `backend`, a `websocket` one by the caller's own\n   * Live Object in `live`. One at a full URL is served elsewhere. */\n  readonly apis: A;\n  /** Every `http` API's handlers on the cloud Backend, made for one request\n   * from the platform's own context, such as a Worker's `env`. */\n  readonly backend?: (env: Env) => {\n    readonly [K in keyof A]?: CloudBackend<RpcsOf<A[K]>>;\n  };\n  /** Every `websocket` API's Live Objects, from the Worker's `env`. A socket\n   * opens at the object named for whoever its token names, so needs `auth`. */\n  readonly live?: (env: Env) => { readonly [K in keyof A]?: LiveNamespace };\n  /** The shared sign-in service, for an app with auth: each call is\n   * checked for the Account its token or cookie names, and the sign-in\n   * cookies refreshed while checking go back on the answer. `resource` is\n   * the audience an Access Token must be for, as a phone's is. */\n  readonly auth?: {\n    readonly url: string;\n    readonly resource?: string | undefined;\n  };\n}\n\nconst isUrl = (path: string) => /^[a-z][a-z0-9+.-]*:\\/\\//i.test(path);\nconst normal = (path: string) => `/${path.replace(/^\\/+|\\/+$/g, '')}`;\n\n/**\n * A web app's server: each of its `http` APIs at its path, on the cloud\n * Backend, each `websocket` one at its path in the caller's own Live\n * Object, and everything else the app's pages, from TanStack Start. A\n * plain fetch handler, so it is a Cloudflare Worker's default export as it\n * is.\n */\nexport const createServer = <A extends Apis, Env>(\n  config: ServerConfig<A, Env>,\n) => {\n  const served = Object.entries(config.apis).filter(\n    ([, api]) => !isUrl(api.path),\n  );\n  const { auth } = config;\n  // A socket for the object of whoever its token names.\n  const openLive = async (request: Request, objects: LiveNamespace) => {\n    if (auth === undefined)\n      return new Response('A Live Object needs auth', { status: 500 });\n    const user = await liveUser(request, auth);\n    if (user === null) return new Response('Unauthorized', { status: 401 });\n    if (user === 'unavailable')\n      return new Response('The sign-in service could not be asked', {\n        status: 503,\n      });\n    return objects.getByName(user).fetch(forOwner(request, user));\n  };\n  return webServer<Env>({\n    route: (request, env) => {\n      const path = normal(new URL(request.url).pathname);\n      const found = served.find(([, api]) => normal(api.path) === path);\n      if (found === undefined) return null;\n      const [name, api] = found;\n      if (api.transport === 'websocket') {\n        const objects = config.live?.(env)[name as keyof A];\n        return objects === undefined\n          ? Promise.resolve(new Response('Not found', { status: 404 }))\n          : openLive(request, objects);\n      }\n      const handlers = config.backend?.(env)[name as keyof A];\n      if (handlers === undefined)\n        return Promise.resolve(new Response('Not found', { status: 404 }));\n      const layer = (\n        auth === undefined\n          ? handlers\n          : handlers.pipe(\n              Layer.provide(\n                authz.cloud({\n                  authWorkerUrl: auth.url,\n                  ...(auth.resource !== undefined && {\n                    resource: auth.resource,\n                  }),\n                }),\n              ),\n            )\n      ) as never;\n      return Rpc.http.server(\n        api.group,\n        layer,\n        ...(auth === undefined ? [] : [{ wrap: authz.cookies }]),\n      )(request);\n    },\n  });\n};\n"],"mappings":";;;;;;AAiDA,MAAM,SAAS,SAAiB,2BAA2B,KAAK,IAAI;AACpE,MAAM,UAAU,SAAiB,IAAI,KAAK,QAAQ,cAAc,EAAE;;;;;;;;AASlE,MAAa,gBACX,WACG;CACH,MAAM,SAAS,OAAO,QAAQ,OAAO,IAAI,CAAC,CAAC,QACxC,GAAG,SAAS,CAAC,MAAM,IAAI,IAAI,CAC9B;CACA,MAAM,EAAE,SAAS;CAEjB,MAAM,WAAW,OAAO,SAAkB,YAA2B;EACnE,IAAI,SAAS,KAAA,GACX,OAAO,IAAI,SAAS,4BAA4B,EAAE,QAAQ,IAAI,CAAC;EACjE,MAAM,OAAO,MAAM,SAAS,SAAS,IAAI;EACzC,IAAI,SAAS,MAAM,OAAO,IAAI,SAAS,gBAAgB,EAAE,QAAQ,IAAI,CAAC;EACtE,IAAI,SAAS,eACX,OAAO,IAAI,SAAS,0CAA0C,EAC5D,QAAQ,IACV,CAAC;EACH,OAAO,QAAQ,UAAU,IAAI,CAAC,CAAC,MAAM,SAAS,SAAS,IAAI,CAAC;CAC9D;CACA,OAAO,UAAe,EACpB,QAAQ,SAAS,QAAQ;EACvB,MAAM,OAAO,OAAO,IAAI,IAAI,QAAQ,GAAG,CAAC,CAAC,QAAQ;EACjD,MAAM,QAAQ,OAAO,MAAM,GAAG,SAAS,OAAO,IAAI,IAAI,MAAM,IAAI;EAChE,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,MAAM,CAAC,MAAM,OAAO;EACpB,IAAI,IAAI,cAAc,aAAa;GACjC,MAAM,UAAU,OAAO,OAAO,GAAG,CAAC,CAAC;GACnC,OAAO,YAAY,KAAA,IACf,QAAQ,QAAQ,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC,CAAC,IAC1D,SAAS,SAAS,OAAO;EAC/B;EACA,MAAM,WAAW,OAAO,UAAU,GAAG,CAAC,CAAC;EACvC,IAAI,aAAa,KAAA,GACf,OAAO,QAAQ,QAAQ,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC,CAAC;EACnE,MAAM,QACJ,SAAS,KAAA,IACL,WACA,SAAS,KACP,MAAM,QACJ,MAAM,MAAM;GACV,eAAe,KAAK;GACpB,GAAI,KAAK,aAAa,KAAA,KAAa,EACjC,UAAU,KAAK,SACjB;EACF,CAAC,CACH,CACF;EAEN,OAAO,IAAI,KAAK,OACd,IAAI,OACJ,OACA,GAAI,SAAS,KAAA,IAAY,CAAC,IAAI,CAAC,EAAE,MAAM,MAAM,QAAQ,CAAC,CACxD,CAAC,CAAC,OAAO;CACX,EACF,CAAC;AACH"}

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

@@ -0,0 +1,2 @@
+import { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage } from "./stage.js";
+export { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage };

package/dist/server/stage/index.js

@@ -0,0 +1,2 @@
+import { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage } from "./stage.js";
+export { assertStageIsSafe, devConfigFor, domainFor, isDeployedStage };

package/dist/server/stage/stage.d.ts

@@ -0,0 +1,14 @@
+//#region src/server/stage/stage.d.ts
+export declare const isDeployedStage: (stage: string) => boolean;
+/** Refuses a deployed stage unless the deploy says so on purpose, as CI and
+ * a deploy script do with ALLOW_DEPLOY=true. */
+export declare const assertStageIsSafe: (stage: string) => void;
+/** Where a stage is served: `domain` for prod, `prN-domain` for a pull
+ * request, and nowhere public for anyone's own stage. */
+export declare const domainFor: (stage: string, domain: string) => string | undefined;
+/** A local stage's dev server, on the PORT `portless run` hands it. */
+export declare const devConfigFor: (isLocal: boolean) => {
+  port: number;
+} | undefined;
+//#endregion
+//# sourceMappingURL=stage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stage.d.ts","names":[],"sources":["../../../src/server/stage/stage.ts"],"mappings":";qBAQa,kBAAe;;;qBAKf,oBAAiB;;;qBAUjB,YAAS,eAAiB;;qBAQ1B,eAAY;EAEpB"}