@plitzi/sdk-shared 0.38.2 → 0.38.4

package/dist/network/graphql/sdk/Queries/InitQuery.d.ts

@@ -10,5 +10,5 @@ export type TInitQuery = {
         };
     };
 };
-declare const InitQuery = "\n  query InitQuery($environment: String!, $revision: Int) {\n    Space(environment: $environment, revision: $revision) {\n      schema {\n        settings\n        rsc\n        flat {\n          id\n          definition {\n            label\n            type\n            initialState\n            styleSelectors\n            bindings\n            interactions\n            parentId\n            rootId\n            items\n            runtime\n            loadStrategy\n            flag {\n              name\n              is\n            }\n            anchor\n          }\n          attributes\n        }\n        pages\n        components\n        flags\n        pageFolders {\n          id\n          name\n          slug\n          parentId\n        }\n        variables {\n          name\n          type\n          value\n          subValues {\n            when\n            value\n          }\n        }\n      }\n      plugins {\n        type\n        resource\n        settings\n      }\n      style {\n        variables\n        cache\n      }\n      # The schema fetch is the one moment a client-side render hears from the server at all, so the decision it\n      # would have been handed in an SSR bootstrap travels here instead.\n      render {\n        overQuota\n      }\n    }\n  }\n";
+declare const InitQuery = "\n  query InitQuery($environment: String!, $revision: Int) {\n    Space(environment: $environment, revision: $revision) {\n      schema {\n        settings\n        rsc\n        flat {\n          id\n          definition {\n            label\n            type\n            initialState\n            styleSelectors\n            bindings\n            interactions\n            parentId\n            rootId\n            items\n            runtime\n            loadStrategy\n            flag {\n              name\n              is\n            }\n            anchor\n            motion {\n              enter\n              on\n              duration\n              delay\n              stagger\n              loop\n            }\n          }\n          attributes\n        }\n        pages\n        components\n        flags\n        pageFolders {\n          id\n          name\n          slug\n          parentId\n        }\n        variables {\n          name\n          type\n          value\n          subValues {\n            when\n            value\n          }\n        }\n      }\n      plugins {\n        type\n        resource\n        settings\n      }\n      style {\n        variables\n        cache\n      }\n      # The schema fetch is the one moment a client-side render hears from the server at all, so the decision it\n      # would have been handed in an SSR bootstrap travels here instead.\n      render {\n        overQuota\n      }\n    }\n  }\n";
 export default InitQuery;

package/dist/network/graphql/sdk/Queries/InitQuery.mjs

@@ -1,4 +1,4 @@
 //#region src/network/graphql/sdk/Queries/InitQuery.ts
-var e = "\n  query InitQuery($environment: String!, $revision: Int) {\n    Space(environment: $environment, revision: $revision) {\n      schema {\n        settings\n        rsc\n        flat {\n          id\n          definition {\n            label\n            type\n            initialState\n            styleSelectors\n            bindings\n            interactions\n            parentId\n            rootId\n            items\n            runtime\n            loadStrategy\n            flag {\n              name\n              is\n            }\n            anchor\n          }\n          attributes\n        }\n        pages\n        components\n        flags\n        pageFolders {\n          id\n          name\n          slug\n          parentId\n        }\n        variables {\n          name\n          type\n          value\n          subValues {\n            when\n            value\n          }\n        }\n      }\n      plugins {\n        type\n        resource\n        settings\n      }\n      style {\n        variables\n        cache\n      }\n      # The schema fetch is the one moment a client-side render hears from the server at all, so the decision it\n      # would have been handed in an SSR bootstrap travels here instead.\n      render {\n        overQuota\n      }\n    }\n  }\n";
+var e = "\n  query InitQuery($environment: String!, $revision: Int) {\n    Space(environment: $environment, revision: $revision) {\n      schema {\n        settings\n        rsc\n        flat {\n          id\n          definition {\n            label\n            type\n            initialState\n            styleSelectors\n            bindings\n            interactions\n            parentId\n            rootId\n            items\n            runtime\n            loadStrategy\n            flag {\n              name\n              is\n            }\n            anchor\n            motion {\n              enter\n              on\n              duration\n              delay\n              stagger\n              loop\n            }\n          }\n          attributes\n        }\n        pages\n        components\n        flags\n        pageFolders {\n          id\n          name\n          slug\n          parentId\n        }\n        variables {\n          name\n          type\n          value\n          subValues {\n            when\n            value\n          }\n        }\n      }\n      plugins {\n        type\n        resource\n        settings\n      }\n      style {\n        variables\n        cache\n      }\n      # The schema fetch is the one moment a client-side render hears from the server at all, so the decision it\n      # would have been handed in an SSR bootstrap travels here instead.\n      render {\n        overQuota\n      }\n    }\n  }\n";
 //#endregion
 export { e as default };

package/dist/schema/motion.d.ts

@@ -0,0 +1,109 @@
+/**
+ * An element's declared motion — how it arrives, when, and whether it keeps moving — which the SDK's own stylesheet
+ * plays (`_motion.scss`). Every preset moves only `opacity` and `transform`, which the compositor animates without
+ * laying the page out again, and every one is stilled for a visitor who asked for less motion: the motion good
+ * practices, kept by construction rather than by the author.
+ *
+ * The one description the authoring package, the builder's Motion tab, the MCP and the validator all read; the
+ * stylesheet mirrors its presets and frames, and a test in `apps/sdk` holds the two together.
+ */
+export declare const MOTION_ENTERS: readonly ["fade", "fade-up", "fade-down", "slide-left", "slide-right", "slide-up", "scale", "zoom-in", "zoom-out", "pop", "bounce-in", "tilt", "spin-in"];
+export type MotionEnter = (typeof MOTION_ENTERS)[number];
+/**
+ * When an arrival plays: as the page loads (`load`); once, as the element first comes into view, and then it stays
+ * (`view`); or with the scroll itself, at the reader's pace — played backwards when the reader scrolls back up past it
+ * (`scroll`).
+ */
+export declare const MOTION_TRIGGERS: readonly ["load", "view", "scroll"];
+export type MotionTrigger = (typeof MOTION_TRIGGERS)[number];
+/**
+ * A motion that repeats: a gentle rise and fall, a breath, a turn, a sway — a bounce, a wobble, a small orbit, a
+ * heartbeat, a drift. Held until the page is live.
+ */
+export declare const MOTION_LOOPS: readonly ["float", "pulse", "spin", "sway", "bounce", "wobble", "orbit", "heartbeat", "drift"];
+export type MotionLoop = (typeof MOTION_LOOPS)[number];
+export interface ElementMotion {
+    /** How it arrives. */
+    enter?: MotionEnter;
+    /** When it arrives: `load` (the default), `view` (once, as it comes into view) or `scroll` (with the scroll). */
+    on?: MotionTrigger;
+    /** How long it takes to arrive, in ms (600 by default). Ignored under `scroll`, which follows the scroll. */
+    duration?: number;
+    /** How long it waits before it does, in ms. */
+    delay?: number;
+    /**
+     * Its CHILDREN arrive one after another, this many ms apart — a grid of cards, a list's rows — rather than the
+     * element itself. Up to the first 24; the rest arrive with the 24th.
+     */
+    stagger?: number;
+    /** Keeps moving after it arrived. */
+    loop?: MotionLoop;
+}
+/** How long an arrival takes when it does not say, and the curve every arrival follows: quick out, gentle in. */
+export declare const MOTION_DEFAULT_DURATION = 600;
+export declare const MOTION_ENTER_EASING = "cubic-bezier(0.2, 0.7, 0.2, 1)";
+/**
+ * One frame of an arrival, `at` a percentage of its duration. It moves the individual `translate`, `scale` and `rotate`
+ * properties — never `transform` — so it composes with a `transform` the element has of its own and with a loop.
+ */
+export interface MotionEnterFrame {
+    at: number;
+    opacity?: number;
+    translate?: string;
+    scale?: string;
+    rotate?: string;
+}
+/**
+ * Each arrival's frames, from where it starts (`at: 0`) through any it passes on the way — an overshoot, a bounce. It
+ * always ends where the element is, which is why no frame says so.
+ */
+export declare const MOTION_ENTER_FRAMES: Record<MotionEnter, MotionEnterFrame[]>;
+/** Where each arrival starts from — its first frame. */
+export declare const MOTION_ENTER_FROM: Record<MotionEnter, Omit<MotionEnterFrame, "at">>;
+/** One frame of a loop: its `transform` at a percentage of its period. A frame no loop names is the element at rest. */
+export interface MotionLoopFrame {
+    at: number;
+    transform: string;
+}
+/**
+ * Each loop's frames, its period and its curve. A loop that swings starts and ends at rest; one that keeps turning
+ * (`spin`) ends a full turn on, which is the same place.
+ */
+export declare const MOTION_LOOP_FRAMES: Record<MotionLoop, {
+    frames: MotionLoopFrame[];
+    periodMs: number;
+    easing: string;
+}>;
+/** The longest a duration, a delay or a stagger may be: past it, a page is waiting on its decoration. */
+export declare const MOTION_MAX_MS = 10000;
+/** What is wrong with a value given as an element's `motion`, one sentence each — empty when it is one. */
+export declare const motionProblems: (value: unknown) => string[];
+export declare const isMotion: (value: unknown) => value is ElementMotion;
+/**
+ * What an element with `motion` carries in the DOM: the presets as `data-motion-*` — what the stylesheet animates by —
+ * and its timings as custom properties. Nothing at all for an element with none, so its markup stays as it was.
+ */
+export declare const motionAttributes: (motion: ElementMotion | undefined) => {
+    attributes: Record<string, string>;
+    style: Record<string, string>;
+};
+/** Every element the SDK's stylesheet moves: an arrival, a staggered child, a loop. */
+export declare const MOVING_SELECTOR = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop]";
+/**
+ * The builder's canvas, held still: what is being edited is shown as it ends up, rather than arriving again on every
+ * change. `MOTION_PLAY_CSS` is the canvas playing — loops included, which a page holds until it is live and an editor
+ * never is.
+ */
+export declare const MOTION_STILL_CSS = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop] { animation: none !important; }";
+/** The attribute an arrival waiting to be seen (`on: 'view'`) gets once it has been, and then keeps (`revealOnView`). */
+export declare const MOTION_SEEN_ATTRIBUTE = "data-motion-seen";
+/** Every element whose arrival waits to be seen: what `revealOnView` watches. */
+export declare const MOTION_VIEW_SELECTOR = "[data-motion-on=\"view\"]";
+/**
+ * Every arrival waiting to be seen, played as if it had been: a surface with nobody scrolling it and no SDK root to
+ * watch it — a preview of an element, a thumbnail — would hold it at its start, unseen.
+ */
+export declare const MOTION_SEEN_CSS = "[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-play-state: running, running !important; }";
+export declare const MOTION_PLAY_CSS: string;
+/** Whether an animation is one of the declared motion's — what replaying the canvas restarts, and nothing else. */
+export declare const isMotionAnimation: (animation: object) => boolean;

package/dist/schema/motion.mjs

@@ -0,0 +1,271 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
+//#region src/schema/motion.ts
+var t = [
+	"fade",
+	"fade-up",
+	"fade-down",
+	"slide-left",
+	"slide-right",
+	"slide-up",
+	"scale",
+	"zoom-in",
+	"zoom-out",
+	"pop",
+	"bounce-in",
+	"tilt",
+	"spin-in"
+], n = [
+	"load",
+	"view",
+	"scroll"
+], r = [
+	"float",
+	"pulse",
+	"spin",
+	"sway",
+	"bounce",
+	"wobble",
+	"orbit",
+	"heartbeat",
+	"drift"
+], i = 600, a = "cubic-bezier(0.2, 0.7, 0.2, 1)", o = {
+	fade: [{
+		at: 0,
+		opacity: 0
+	}],
+	"fade-up": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 24px"
+	}],
+	"fade-down": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 -24px"
+	}],
+	"slide-left": [{
+		at: 0,
+		opacity: 0,
+		translate: "32px 0"
+	}],
+	"slide-right": [{
+		at: 0,
+		opacity: 0,
+		translate: "-32px 0"
+	}],
+	"slide-up": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 72px"
+	}],
+	scale: [{
+		at: 0,
+		opacity: 0,
+		scale: "0.94"
+	}],
+	"zoom-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.6"
+	}],
+	"zoom-out": [{
+		at: 0,
+		opacity: 0,
+		scale: "1.25"
+	}],
+	pop: [
+		{
+			at: 0,
+			opacity: 0,
+			scale: "0.5"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			scale: "1.08"
+		},
+		{
+			at: 78,
+			scale: "0.97"
+		}
+	],
+	"bounce-in": [
+		{
+			at: 0,
+			opacity: 0,
+			translate: "0 -64px"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			translate: "0 10px"
+		},
+		{
+			at: 75,
+			translate: "0 -5px"
+		},
+		{
+			at: 90,
+			translate: "0 2px"
+		}
+	],
+	tilt: [{
+		at: 0,
+		opacity: 0,
+		translate: "0 32px",
+		rotate: "-6deg"
+	}],
+	"spin-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.4",
+		rotate: "-180deg"
+	}]
+}, s = Object.fromEntries(t.map((e) => {
+	let [{ at: t, ...n }] = o[e];
+	return [e, n];
+})), c = (e, t) => {
+	let n = t * 2 * Math.PI, r = Math.round(Math.sin(n) * e * 10) / 10, i = Math.round(-Math.cos(n) * e * 10) / 10;
+	return `translate(${String(r)}px, ${String(i)}px)`;
+}, l = {
+	float: {
+		frames: [{
+			at: 50,
+			transform: "translateY(-8px)"
+		}],
+		periodMs: 6e3,
+		easing: "ease-in-out"
+	},
+	pulse: {
+		frames: [{
+			at: 50,
+			transform: "scale(1.04)"
+		}],
+		periodMs: 3e3,
+		easing: "ease-in-out"
+	},
+	spin: {
+		frames: [{
+			at: 100,
+			transform: "rotate(360deg)"
+		}],
+		periodMs: 12e3,
+		easing: "linear"
+	},
+	sway: {
+		frames: [{
+			at: 50,
+			transform: "rotate(2deg)"
+		}],
+		periodMs: 5e3,
+		easing: "ease-in-out"
+	},
+	bounce: {
+		frames: [
+			{
+				at: 0,
+				transform: "translateY(0) scale(1.03, 0.97)"
+			},
+			{
+				at: 45,
+				transform: "translateY(-14px) scale(0.98, 1.02)"
+			},
+			{
+				at: 55,
+				transform: "translateY(-14px) scale(0.98, 1.02)"
+			},
+			{
+				at: 100,
+				transform: "translateY(0) scale(1.03, 0.97)"
+			}
+		],
+		periodMs: 1400,
+		easing: "ease-in-out"
+	},
+	wobble: {
+		frames: [{
+			at: 25,
+			transform: "rotate(-5deg)"
+		}, {
+			at: 75,
+			transform: "rotate(5deg)"
+		}],
+		periodMs: 2400,
+		easing: "ease-in-out"
+	},
+	orbit: {
+		frames: Array.from({ length: 9 }, (e, t) => ({
+			at: t * 100 / 8,
+			transform: c(6, t / 8)
+		})),
+		periodMs: 8e3,
+		easing: "linear"
+	},
+	heartbeat: {
+		frames: [
+			{
+				at: 14,
+				transform: "scale(1.1)"
+			},
+			{
+				at: 28,
+				transform: "scale(1)"
+			},
+			{
+				at: 42,
+				transform: "scale(1.07)"
+			},
+			{
+				at: 70,
+				transform: "scale(1)"
+			}
+		],
+		periodMs: 1600,
+		easing: "ease-in-out"
+	},
+	drift: {
+		frames: [{
+			at: 50,
+			transform: "translateX(12px)"
+		}],
+		periodMs: 7e3,
+		easing: "ease-in-out"
+	}
+}, u = 1e4, d = (e, t) => typeof t == "string" && e.includes(t), f = /* @__PURE__ */ new Set([
+	"enter",
+	"on",
+	"duration",
+	"delay",
+	"stagger",
+	"loop"
+]), p = (i) => {
+	if (!e(i)) return ["motion is an object: `{ enter: 'fade-up', on: 'view' }`"];
+	let a = [];
+	for (let e of Object.keys(i)) f.has(e) || a.push(`motion has no "${e}" — it takes enter, on, duration, delay, stagger and loop`);
+	i.enter !== void 0 && !d(t, i.enter) && a.push(`motion.enter is one of ${t.join(", ")}`), i.on !== void 0 && !d(n, i.on) && a.push(`motion.on is ${n.slice(0, -1).join(", ")} or ${String(n.at(-1))}`), i.loop !== void 0 && !d(r, i.loop) && a.push(`motion.loop is one of ${r.join(", ")}`);
+	for (let e of [
+		"duration",
+		"delay",
+		"stagger"
+	]) {
+		let t = i[e];
+		t !== void 0 && (typeof t != "number" || !Number.isFinite(t) || t < 0 || t > 1e4) && a.push(`motion.${e} is a number of ms from 0 to ${String(u)}`);
+	}
+	return i.enter === void 0 && i.loop === void 0 && a.push("motion says nothing to play: give it an `enter`, a `loop`, or both"), i.stagger !== void 0 && i.enter === void 0 && a.push("motion.stagger staggers the children’s `enter`: give it one"), a;
+}, m = (e) => p(e).length === 0, h = (e) => {
+	if (!e) return {
+		attributes: {},
+		style: {}
+	};
+	let t = {}, n = {};
+	return e.enter && (t[e.stagger === void 0 ? "data-motion-enter" : "data-motion-stagger"] = e.enter, t["data-motion-on"] = e.on ?? "load"), e.loop && (t["data-motion-loop"] = e.loop), e.duration !== void 0 && (n["--plitzi-motion-duration"] = `${String(e.duration)}ms`), e.delay !== void 0 && (n["--plitzi-motion-delay"] = `${String(e.delay)}ms`), e.stagger !== void 0 && (n["--plitzi-motion-stagger"] = `${String(e.stagger)}ms`), {
+		attributes: t,
+		style: n
+	};
+}, g = "[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop]", _ = `${g} { animation: none !important; }`, v = "data-motion-seen", y = "[data-motion-on=\"view\"]", b = "[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-play-state: running, running !important; }", x = [
+	"[data-motion-loop] { animation-play-state: running, running !important; }",
+	b,
+	"[data-motion-on=\"scroll\"][data-motion-enter], [data-motion-on=\"scroll\"][data-motion-stagger] > * { animation-timeline: auto, auto !important; }"
+].join("\n"), S = (e) => "animationName" in e && typeof e.animationName == "string" && e.animationName.startsWith("plitzi-motion-");
+//#endregion
+export { i as MOTION_DEFAULT_DURATION, t as MOTION_ENTERS, a as MOTION_ENTER_EASING, o as MOTION_ENTER_FRAMES, s as MOTION_ENTER_FROM, r as MOTION_LOOPS, l as MOTION_LOOP_FRAMES, u as MOTION_MAX_MS, x as MOTION_PLAY_CSS, v as MOTION_SEEN_ATTRIBUTE, b as MOTION_SEEN_CSS, _ as MOTION_STILL_CSS, n as MOTION_TRIGGERS, y as MOTION_VIEW_SELECTOR, g as MOVING_SELECTOR, m as isMotion, S as isMotionAnimation, h as motionAttributes, p as motionProblems };

package/dist/schema/motionReveal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Plays every arrival under `root` that waits to be seen (`motion: { on: 'view' }`) the first time it comes into view,
+ * and never again: the stylesheet holds it at its start until the element carries `data-motion-seen`, which this sets
+ * and nothing takes off. Elements added later — a page navigated to, a list's new rows — are watched as they arrive.
+ * Answers the function that stops watching.
+ *
+ * One observer for the whole tree rather than one per element: a page of cards is hundreds of them. A browser without
+ * `IntersectionObserver` shows each arrival at once, as one that cannot know what is on screen.
+ */
+export declare const revealOnView: (root: Element) => (() => void);

package/dist/schema/motionReveal.mjs

@@ -0,0 +1,23 @@
+import { MOTION_SEEN_ATTRIBUTE as e, MOTION_VIEW_SELECTOR as t } from "./motion.mjs";
+//#region src/schema/motionReveal.ts
+var n = `${t}:not([${e}])`, r = (t) => {
+	let r = (t) => t.setAttribute(e, ""), i = (e) => [...e.matches(n) ? [e] : [], ...Array.from(e.querySelectorAll(n))];
+	if (typeof Reflect.get(globalThis, "IntersectionObserver") != "function") return i(t).forEach(r), () => void 0;
+	let a = new IntersectionObserver((e) => {
+		for (let t of e) t.isIntersecting && (r(t.target), a.unobserve(t.target));
+	}), o = (e) => i(e).forEach((e) => a.observe(e)), s = new MutationObserver((e) => {
+		for (let t of e) t.type === "attributes" && t.target instanceof Element && o(t.target), t.addedNodes.forEach((e) => {
+			e instanceof Element && o(e);
+		});
+	});
+	return o(t), s.observe(t, {
+		childList: !0,
+		subtree: !0,
+		attributes: !0,
+		attributeFilter: ["data-motion-on"]
+	}), () => {
+		a.disconnect(), s.disconnect();
+	};
+};
+//#endregion
+export { r as revealOnView };

package/dist/schema/wire.mjs

@@ -2,26 +2,35 @@
 var e = (e) => ({
 	...e,
 	flat: Object.values(e.flat)
-}), t = ({ definition: e, ...t }) => {
-	let { parentId: n, items: r, bindings: i, interactions: a, initialState: o, runtime: s, loadStrategy: c, flag: l, anchor: u, ...d } = e;
+}), t = (e) => ({
+	...e.enter ? { enter: e.enter } : {},
+	...e.on ? { on: e.on } : {},
+	...typeof e.duration == "number" ? { duration: e.duration } : {},
+	...typeof e.delay == "number" ? { delay: e.delay } : {},
+	...typeof e.stagger == "number" ? { stagger: e.stagger } : {},
+	...e.loop ? { loop: e.loop } : {}
+}), n = ({ definition: e, ...n }) => {
+	let { parentId: r, items: i, bindings: a, interactions: o, initialState: s, runtime: c, loadStrategy: l, flag: u, anchor: d, motion: f, quiet: p, ...m } = e;
 	return {
-		...t,
+		...n,
 		definition: {
-			...d,
-			...n == null ? {} : { parentId: n },
-			...r == null ? {} : { items: r },
-			...i == null ? {} : { bindings: i },
-			...a == null ? {} : { interactions: a },
-			...o == null ? {} : { initialState: o },
-			...s == null ? {} : { runtime: s },
-			...c == null ? {} : { loadStrategy: c },
-			...l == null ? {} : { flag: l },
-			...u == null ? {} : { anchor: u }
+			...m,
+			...r == null ? {} : { parentId: r },
+			...i == null ? {} : { items: i },
+			...a == null ? {} : { bindings: a },
+			...o == null ? {} : { interactions: o },
+			...s == null ? {} : { initialState: s },
+			...c == null ? {} : { runtime: c },
+			...l == null ? {} : { loadStrategy: l },
+			...u == null ? {} : { flag: u },
+			...d == null ? {} : { anchor: d },
+			...f == null ? {} : { motion: t(f) },
+			...p == null ? {} : { quiet: p }
 		}
 	};
-}, n = (e) => ({
+}, r = (e) => ({
 	...e,
-	flat: Object.fromEntries(e.flat.map((e) => [e.id, t(e)]))
+	flat: Object.fromEntries(e.flat.map((e) => [e.id, n(e)]))
 });
 //#endregion
-export { t as elementFromWire, n as schemaFromWire, e as schemaToWire };
+export { n as elementFromWire, r as schemaFromWire, e as schemaToWire };

package/dist/source/export.d.ts

@@ -28,6 +28,11 @@ export type SpaceExport = {
     };
     /** The version taken out: the draft (`main`, revision 0), or a snapshot an environment holds. */
     version: Pick<SpaceVersionContents, 'environment' | 'revision' | 'snapshot'>;
+    /**
+     * Which state of the draft's documents this is — its schema, style, actions and connectors — what `plitzi push`
+     * checks the space's draft has not moved on from. `null` for a snapshot, which no push writes.
+     */
+    draft: string | null;
     /** The space as authoring code, by path (`index.ts`, a file per page): none for a project that reads it from Plitzi. */
     authoring: {
         exportName: string;

package/dist/source/import.d.ts

@@ -0,0 +1,55 @@
+import { Schema, Style } from '../types';
+/**
+ * A project's space put back on Plitzi as the space's draft (docs/en/projects-from-spaces.md): what `plitzi push` sends
+ * to `PUT /spaces/:spaceId/import`, and what it is answered. The way back of `SpaceExport` — one shape for both ends.
+ */
+export declare const SPACE_IMPORT_FORMAT = 1;
+export type SpaceImport = {
+    format: typeof SPACE_IMPORT_FORMAT;
+    /** The space as the project authors it: the two documents the draft is made of, replaced whole. */
+    documents: {
+        schema: Schema;
+        style: Style;
+    };
+    /**
+     * Every server action the project keeps, and every connector: the space's become exactly these. Left out, the project
+     * keeps none of its own, and the space's are left as they are.
+     */
+    actions?: {
+        identifier: string;
+        name: string;
+        document: unknown;
+    }[];
+    connectors?: {
+        identifier: string;
+        name: string;
+        manifest: unknown;
+    }[];
+    /**
+     * The draft the project was last given or last pushed (`SpaceExport.draft`): the push is refused when the space's has
+     * moved on since. `null` for a project that never had one — refused unless the space is still as it was created.
+     */
+    base: string | null;
+    /** Replace the draft whatever it holds now. */
+    force: boolean;
+};
+/** Why a push was not taken, before anything was checked: the draft is not the one the project knows. */
+export type SpaceImportRefusalCode = 'DRAFT_MOVED' | 'DRAFT_NOT_EMPTY';
+export type SpaceImportResult = 
+/** Taken: `draft` is what the project knows from now on; `changed` false when it already was the space's draft. */
+{
+    ok: true;
+    changed: boolean;
+    draft: string;
+} | {
+    ok: false;
+    refusal: {
+        code: SpaceImportRefusalCode;
+        error: string;
+    };
+}
+/** Not taken: what is wrong with what was sent, each problem where it is. */
+ | {
+    ok: false;
+    problems: string[];
+};

package/dist/source/import.mjs

@@ -0,0 +1,4 @@
+//#region src/source/import.ts
+var e = 1;
+//#endregion
+export { e as SPACE_IMPORT_FORMAT };

package/dist/source/index.d.ts

@@ -1,4 +1,6 @@
 export { readSourceSnapshot, secretIn, sourcePathProblem, SOURCE_SNAPSHOT_FORMAT, SOURCE_SNAPSHOT_LIMITS } from './snapshot';
 export { SPACE_EXPORT_FORMAT } from './export';
+export { SPACE_IMPORT_FORMAT } from './import';
 export type { SourceSnapshot, SourceSnapshotKind, SourceSnapshotReading } from './snapshot';
 export type { SpaceExport, SpaceExportConflict, SpaceExportFile } from './export';
+export type { SpaceImport, SpaceImportRefusalCode, SpaceImportResult } from './import';

package/dist/source/index.mjs

@@ -1,3 +1,4 @@
 import { SPACE_EXPORT_FORMAT as e } from "./export.mjs";
-import { SOURCE_SNAPSHOT_FORMAT as t, SOURCE_SNAPSHOT_LIMITS as n, readSourceSnapshot as r, secretIn as i, sourcePathProblem as a } from "./snapshot.mjs";
-export { t as SOURCE_SNAPSHOT_FORMAT, n as SOURCE_SNAPSHOT_LIMITS, e as SPACE_EXPORT_FORMAT, r as readSourceSnapshot, i as secretIn, a as sourcePathProblem };
+import { SPACE_IMPORT_FORMAT as t } from "./import.mjs";
+import { SOURCE_SNAPSHOT_FORMAT as n, SOURCE_SNAPSHOT_LIMITS as r, readSourceSnapshot as i, secretIn as a, sourcePathProblem as o } from "./snapshot.mjs";
+export { n as SOURCE_SNAPSHOT_FORMAT, r as SOURCE_SNAPSHOT_LIMITS, e as SPACE_EXPORT_FORMAT, t as SPACE_IMPORT_FORMAT, i as readSourceSnapshot, a as secretIn, o as sourcePathProblem };