@karagoz/hayali 0.0.0-stage → 0.6.0

package/dist/parse.js

@@ -0,0 +1,521 @@
+import e from "markdown-it";
+import { LineCounter as t, isMap as n, isSeq as r, parseDocument as i } from "yaml";
+//#region src/parse/body.ts
+var a = (e, t, n, r) => {
+	let i = [], a = !0, o = t, s = (t) => {
+		for (; o < t; o++) {
+			let t = e[o];
+			a && t.trim() === "" || (a = !1, i.push(t));
+		}
+	};
+	for (let [e, t] of [...r].sort((e, t) => e[0] - t[0])) s(e), o = t, a = i.length === 0 || i[i.length - 1].trim() === "";
+	return s(n), i.join("\n").trim();
+}, o = "krgz-", s = "krgz-lesson", c = "krgz-step", l = (e, a, o) => {
+	let s = new t(), c = i(e, { lineCounter: s }), l = (e) => {
+		let { line: t, col: n } = s.linePos(e);
+		return {
+			line: a + t - 1,
+			column: n
+		};
+	}, u = /* @__PURE__ */ new Map(), d = (e, t) => {
+		if (n(e)) for (let n of e.items) {
+			let e = String(n.key?.value), r = t ? `${t}.${e}` : e, i = n.key?.range;
+			i && u.set(r, l(i[0])), d(n.value, r);
+		}
+		else r(e) && e.items.forEach((e, n) => {
+			let r = `${t}.${n}`, i = e?.range;
+			i && u.set(r, l(i[0])), d(e, r);
+		});
+	};
+	d(c.contents, "");
+	for (let e of c.errors) o.push({
+		rule: "malformed-yaml",
+		message: e.message.split("\n")[0],
+		...l(e.pos[0])
+	});
+	let f = (e) => u.get(e) ?? {
+		line: a,
+		column: 1
+	};
+	return c.errors.length > 0 ? {
+		data: void 0,
+		at: f
+	} : c.contents === null ? {
+		data: {},
+		at: f
+	} : n(c.contents) ? {
+		data: c.toJS(),
+		at: f
+	} : (o.push({
+		rule: "invalid-value",
+		message: "A krgz block must be a YAML mapping.",
+		...f("")
+	}), {
+		data: void 0,
+		at: f
+	});
+}, u = (e) => typeof e == "object" && !!e && !Array.isArray(e), d = (e) => Array.isArray(e) && e.every((e) => typeof e == "string"), f = /^\d+$/, p = /^(\d+)\s*-\s*(\d+)$/, m = (e) => {
+	let t = e.split(",").map((e) => e.trim()), n = [];
+	for (let e of t) {
+		let t = p.exec(e);
+		if (f.test(e)) n.push(Number(e));
+		else if (t) n.push([Number(t[1]), Number(t[2])]);
+		else return;
+	}
+	return n.length === 1 ? n[0] : n.length === 2 && n.every((e) => typeof e == "number") ? n.map((e) => [e, e]) : n;
+}, h = (e, t, n, r) => {
+	for (let i of Object.keys(e)) t.includes(i) || r("unknown-key", n + i, `Unknown key "${i}"; expected one of ${t.join(", ")}.`);
+}, g = (e, t) => {
+	h(e, ["immutable"], "", t);
+	let n = {};
+	return "immutable" in e && (d(e.immutable) ? n.immutable = e.immutable : t("invalid-value", "immutable", "immutable must be a list of paths.")), n;
+}, _ = (e, t) => {
+	if (!u(e)) {
+		t("invalid-value", "editor", "editor must be a mapping.");
+		return;
+	}
+	h(e, [
+		"open",
+		"close",
+		"highlight"
+	], "editor.", t);
+	let n = {};
+	if ("open" in e) {
+		let r = e.open;
+		Array.isArray(r) && r.every((e) => typeof e == "string" || u(e) && typeof e.path == "string" && (e.line === void 0 || typeof e.line == "number")) ? n.open = r : t("invalid-value", "editor.open", "editor.open must be a list of paths or { path, line }.");
+	}
+	if ("close" in e && (e.close === "all" || d(e.close) ? n.close = e.close : t("invalid-value", "editor.close", "editor.close must be \"all\" or a list of paths.")), "highlight" in e) {
+		let r = e.highlight;
+		if (!Array.isArray(r)) t("invalid-value", "editor.highlight", "editor.highlight must be a list of { path, lines }.");
+		else {
+			let e = [];
+			r.forEach((n, r) => {
+				let i = `editor.highlight.${r}`;
+				if (!u(n) || typeof n.path != "string") {
+					t("invalid-value", i, "Each highlight needs a path and lines.");
+					return;
+				}
+				h(n, ["path", "lines"], `${i}.`, t);
+				let a = n.lines;
+				if (typeof a == "string") {
+					let e = m(a);
+					if (e === void 0) {
+						t("invalid-value", `${i}.lines`, `Cannot read "${a}" as lines; use a form like 1-7, 13-17.`);
+						return;
+					}
+					a = e;
+				}
+				if (a === void 0) {
+					t("invalid-value", i, "Each highlight needs a path and lines.");
+					return;
+				}
+				e.push({
+					path: n.path,
+					lines: a
+				});
+			}), n.highlight = e;
+		}
+	}
+	return n;
+}, v = (e, t) => {
+	h(e, [
+		"removals",
+		"locks",
+		"editor",
+		"preview",
+		"carry"
+	], "", t);
+	let n = {};
+	"carry" in e && (typeof e.carry == "string" && e.carry !== "" ? n.carry = e.carry : t("invalid-value", "carry", "carry must be one step reference."));
+	for (let r of ["removals", "locks"]) r in e && (d(e[r]) ? n[r] = e[r] : t("invalid-value", r, `${r} must be a list of paths.`));
+	if ("editor" in e) {
+		let r = _(e.editor, t);
+		r && (n.editor = r);
+	}
+	if ("preview" in e) {
+		let r = e.preview;
+		u(r) && typeof r.url == "string" ? (h(r, ["url"], "preview.", t), n.preview = { url: r.url }) : t("invalid-value", "preview", "preview must be { url: <string> }.");
+	}
+	return n;
+}, y = /* @__PURE__ */ new Set([
+	"file",
+	"from",
+	"src"
+]), b = (e) => {
+	let t = [], n = /* @__PURE__ */ new Map();
+	for (let r of e.matchAll(/([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|(\S*)))?/g)) {
+		let [, e, i, a, o] = r;
+		r[0].includes("=") ? n.set(e, i ?? a ?? o ?? "") : y.has(e) ? n.set(e, "") : t.push(e);
+	}
+	return {
+		words: t,
+		attrs: n
+	};
+}, x = (e, t, n) => Object.defineProperty(e, t, {
+	value: n,
+	enumerable: !0,
+	writable: !0,
+	configurable: !0
+}), S = (e) => e.split("/").filter((e) => e !== "" && e !== "."), C = (e) => S(e).join("/"), w = (e, t) => {
+	for (let n of e) if (n === t || n.startsWith(`${t}/`) || t.startsWith(`${n}/`)) return !0;
+	return !1;
+}, T = (e, t, n) => {
+	let r = S(t), i = r.pop();
+	if (i === void 0) return;
+	let a = e;
+	for (let e of r) {
+		let t = Object.getOwnPropertyDescriptor(a, e)?.value;
+		if (t && "directory" in t) {
+			a = t.directory;
+			continue;
+		}
+		let n = {};
+		x(a, e, { directory: n }), a = n;
+	}
+	x(a, i, { file: { contents: n } });
+}, E = (e) => {
+	if (e === "" || e.startsWith("/") || e.includes("\\") || /^[A-Za-z]:/.test(e)) return;
+	let t = [];
+	for (let n of e.split("/")) if (!(n === "" || n === ".")) if (n === "..") {
+		if (t.pop() === void 0) return;
+	} else t.push(n);
+	return t.length > 0 ? t.join("/") : void 0;
+}, D = (e, { fail: t, resolveSrc: n, srcPaths: r }) => {
+	let { attrs: i, content: a, path: o } = e, s = i.get("from"), c = i.get("src"), l = a.trim() !== "";
+	if (s !== void 0 && c !== void 0) {
+		t("conflicting-file-source", `"${o}" cannot take its content from both from= and src=.`);
+		return;
+	}
+	if (s !== void 0) {
+		if (!l) return {
+			kind: "from",
+			ref: s
+		};
+		t("ref-with-body", `"${o}" reuses another step's file, so its fence must be empty.`);
+		return;
+	}
+	if (c === void 0) return {
+		kind: "literal",
+		contents: a
+	};
+	if (l) {
+		t("src-with-body", `"${o}" takes its content from src=, so its fence must be empty.`);
+		return;
+	}
+	let u = E(c);
+	if (u === void 0) {
+		t("invalid-src", `src="${c}" must be a relative path inside the lesson's folder.`);
+		return;
+	}
+	let d;
+	if (n) {
+		r.includes(u) || r.push(u);
+		try {
+			d = n(u);
+		} catch {
+			d = void 0;
+		}
+	}
+	if (typeof d != "string") {
+		t("unresolved-src", `Could not read src="${u}" for "${o}".`);
+		return;
+	}
+	return {
+		kind: "literal",
+		contents: d
+	};
+}, O = (e, t, n) => {
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) r.set(`${e.chapterId}/${e.stepId}`, e);
+	let i = (t, n, i = !0) => {
+		if (n === "base" && i) return e;
+		let a = n.split("/");
+		if (a.length === 2) return r.get(n);
+		if (a.length === 1 && t.chapterId !== void 0) return r.get(`${t.chapterId}/${n}`);
+	}, a = (e) => ({
+		chapterId: e.chapterId,
+		stepId: e.stepId,
+		column: e.carry?.column
+	});
+	for (let e of t) {
+		if (!e.carry) continue;
+		let t = i(e, e.carry.ref, !1);
+		t ? e.carryTarget = t : n("carry-unknown-step", e.carry.line, `No step "${e.carry.ref}" to carry.`, a(e));
+	}
+	let o = /* @__PURE__ */ new Set();
+	for (let e of t) {
+		let t = [], r = e;
+		for (; r && !o.has(r);) {
+			if (t.includes(r)) {
+				n("carry-cycle", r.carry?.line ?? 0, `Carrying "${r.carry?.ref}" leads back to this step.`, a(r)), r.carryTarget = void 0;
+				break;
+			}
+			t.push(r), r = r.carryTarget;
+		}
+		for (let e of t) o.add(e);
+	}
+	for (let e of t) {
+		let t = e.carryTarget;
+		if (!t) continue;
+		let r = new Set(e.removals), i = (t.removals ?? []).filter((e) => !r.has(e));
+		i.length > 0 && n("carry-drops-removals", e.carry?.line ?? 0, `"${e.carry?.ref}" removes ${i.join(", ")}, which this step carries back in.`, {
+			...a(e),
+			severity: "warning"
+		});
+	}
+	let s = (e, t) => {
+		let n = e.entries.get(t);
+		return n ? {
+			scope: e,
+			entry: n
+		} : e.carryTarget ? s(e.carryTarget, t) : void 0;
+	}, c = (e) => [.../* @__PURE__ */ new Set([...e.carryTarget ? c(e.carryTarget) : [], ...e.entries.keys()])], l = /* @__PURE__ */ new Map(), u = (e, t) => {
+		let r = {
+			chapterId: e.chapterId,
+			stepId: e.stepId,
+			path: t.path
+		}, a = l.get(t);
+		if (a) return a.done || n("ref-cycle", t.line, `"${t.path}" refers back to itself.`, r), a.value;
+		let o = { done: !1 };
+		if (l.set(t, o), t.source.kind === "literal") o.value = t.source.contents;
+		else {
+			let a = i(e, t.source.ref), c = a && s(a, t.path);
+			a ? c ? o.value = u(c.scope, c.entry) : n("ref-missing-path", t.line, `"${t.source.ref}" has no "${t.path}" of its own to reuse.`, r) : n("ref-unknown-step", t.line, `No step "${t.source.ref}" to reuse "${t.path}" from.`, r);
+		}
+		return o.done = !0, o.value;
+	}, d = /* @__PURE__ */ new Map();
+	for (let n of [e, ...t]) for (let e of c(n)) {
+		let t = s(n, e), r = t && u(t.scope, t.entry);
+		if (r === void 0) continue;
+		let i = d.get(n);
+		i || d.set(n, i = {}), T(i, e, r);
+	}
+	return d;
+}, k = new e(), A = /^[A-Za-z0-9_-]+$/, j = /^(.*?)\s*\{#([^{}]*)\}\s*$/, M = (e, t) => {
+	let n = e.replace(/^(\s*>)*\s*/, "").trimEnd(), r = t[0];
+	return n.length >= t.length && [...n].every((e) => e === r);
+}, N = (e) => e.type === "heading_open" && e.level === 0 && (e.tag === "h1" || e.tag === "h2"), P = (e, { resolveSrc: t } = {}) => {
+	let n = [], r = [], i = (e, t, r, i = {}) => n.push({
+		rule: e,
+		severity: "error",
+		message: r,
+		line: t + 1,
+		...i
+	}), u = e.split(/\r\n|\r|\n/), d = [];
+	try {
+		d = k.parse(e, {});
+	} catch {
+		d = [];
+	}
+	for (let e of d) {
+		if (e.type !== "fence" || !e.map) continue;
+		let [t, n] = e.map;
+		(n - t < 2 || !M(u[n - 1] ?? "", e.markup)) && i("unclosed-fence", t, "Code fence is never closed.");
+	}
+	let f = [];
+	d.forEach((e, t) => {
+		!N(e) || !e.map || f.push({
+			level: e.tag === "h1" ? 1 : 2,
+			line: e.map[0],
+			text: d[t + 1]?.content ?? ""
+		});
+	});
+	let p = [], m, h = !1, _ = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map();
+	f.forEach((e, t) => {
+		let n = f[t + 1], r = e.level === 1 ? "Chapter" : "Step", a = j.exec(e.text), o = m && e.level === 2 ? { chapterId: m.id } : {}, s;
+		if (a ? A.test(a[2]) ? s = a[2] : i("invalid-id", e.line, `${r} id "${a[2]}" must match [A-Za-z0-9_-]+.`, o) : i("missing-id", e.line, `${r} heading needs an {#id}.`, o), e.level === 1) {
+			if (h = s === void 0, m = void 0, s === void 0) return;
+			if (p.some((e) => e.id === s)) {
+				h = !0, i("duplicate-id", e.line, `Chapter id "${s}" is used twice.`, { chapterId: s });
+				return;
+			}
+			m = {
+				id: s,
+				title: a[1],
+				steps: []
+			}, p.push(m), y.set(m, e.line), S.set(e, { chapter: m });
+			return;
+		}
+		if (!m) {
+			h || i("step-outside-chapter", e.line, "Step heading comes before any chapter heading.");
+			return;
+		}
+		if (s === void 0) return;
+		if (m.steps.some((e) => e.id === s)) {
+			i("duplicate-id", e.line, `Step id "${s}" is used twice.`, {
+				chapterId: m.id,
+				stepId: s
+			});
+			return;
+		}
+		let c = {
+			id: s,
+			title: a[1],
+			body: ""
+		};
+		m.steps.push(c), S.set(e, {
+			step: c,
+			chapter: m
+		}), x.set(c, {
+			chapterId: m.id,
+			stepId: c.id,
+			entries: /* @__PURE__ */ new Map()
+		}), _.set(c, {
+			start: e.line + 1,
+			end: n?.line ?? u.length
+		});
+	});
+	let T = (e) => {
+		let t = "base";
+		for (let n of f) {
+			if (n.line > e) break;
+			t = S.get(n) ?? "rejected";
+		}
+		return t;
+	}, E = { entries: /* @__PURE__ */ new Map() }, P = /* @__PURE__ */ new Map(), F = (e, t) => {
+		if (!e) return;
+		let n = P.get(e) ?? [];
+		n.push(t), P.set(e, n);
+	}, I = !1, L = /* @__PURE__ */ new Set(), R = {}, z = (e, t, r, a) => {
+		let o = e.map[0], u = r === "base" ? void 0 : r.step;
+		if (t !== "krgz-lesson" && t !== "krgz-step") {
+			i("unknown-fence", o, `Unknown fence "${t}".`, a);
+			return;
+		}
+		if (t === "krgz-lesson") {
+			if (r !== "base") {
+				i("misplaced-lesson-block", o, `${s} must come before the first chapter heading.`, a);
+				return;
+			}
+			if (I) {
+				i("duplicate-lesson-block", o, `Only one ${s} block is allowed.`);
+				return;
+			}
+			I = !0;
+		} else {
+			if (!u) {
+				i("misplaced-step-block", o, `${c} must sit inside a step.`, a);
+				return;
+			}
+			if (L.has(u)) {
+				i("duplicate-step-block", o, `Only one ${c} block is allowed per step.`, a);
+				return;
+			}
+			L.add(u);
+		}
+		let d = [], f = l(e.content, o + 1, d), p = (e, t, n) => d.push({
+			rule: e,
+			message: n,
+			...f.at(t)
+		});
+		if (f.data) if (u) {
+			let { carry: e, ...t } = v(f.data, p);
+			Object.assign(u, t);
+			let n = x.get(u);
+			n && (n.removals = (t.removals ?? []).map(C), e && (n.carry = {
+				ref: e,
+				...f.at("carry")
+			}));
+		} else R = g(f.data, p);
+		for (let e of d) n.push({
+			rule: e.rule,
+			severity: "error",
+			message: e.message,
+			line: e.line + 1,
+			column: e.column,
+			...a
+		});
+	}, B = (e, n, a, o) => {
+		let s = e.map[0], c = a === "base" ? void 0 : a.step;
+		if (a !== "base" && !c) {
+			i("file-outside-step", s, "A file fence must sit inside a step or before the first chapter.", o);
+			return;
+		}
+		let l = C(n.get("file") ?? "");
+		if (l === "") {
+			i("missing-file-path", s, "File fence needs file=<path>.", o);
+			return;
+		}
+		let u = (e, t) => i(e, s, t, {
+			...o,
+			path: l
+		}), d = c && x.get(c) || E;
+		if (w(d.entries.keys(), l)) {
+			u("duplicate-file", `File "${l}" is defined twice.`);
+			return;
+		}
+		let f = D({
+			attrs: n,
+			content: e.content,
+			path: l
+		}, {
+			fail: u,
+			resolveSrc: t,
+			srcPaths: r
+		});
+		f && d.entries.set(l, {
+			path: l,
+			line: s,
+			source: f
+		});
+	};
+	for (let e of d) {
+		if (e.type !== "fence" || e.level !== 0 || !e.map) continue;
+		let { words: t, attrs: n } = b(e.info), r = t.find((e) => e.startsWith(o));
+		if (!r && !n.has("file")) continue;
+		let i = T(e.map[0]);
+		if (i === "rejected") continue;
+		let a = i === "base" ? void 0 : i.step, s = i === "base" ? {} : {
+			chapterId: i.chapter.id,
+			stepId: a?.id
+		};
+		F(a, [e.map[0], e.map[1]]), r ? z(e, r, i, s) : B(e, n, i, s);
+	}
+	let V = O(E, [...x.values()], i);
+	for (let [e, { start: t, end: n }] of _) {
+		e.body = a(u, t, n, P.get(e) ?? []);
+		let r = V.get(x.get(e));
+		r && (e.adjustments = r);
+	}
+	for (let e of p) e.steps.length > 0 || i("empty-chapter", y.get(e) ?? 0, `Chapter "${e.id}" has no steps.`, { chapterId: e.id });
+	let H = {
+		chapters: p,
+		...R
+	}, U = V.get(E);
+	return U && (H.files = U), {
+		lesson: H,
+		issues: n.sort((e, t) => e.line - t.line),
+		srcPaths: r,
+		locate: ({ chapterId: e, stepId: t, path: n }) => {
+			let r = p.find((t) => t.id === e);
+			if (!r) return;
+			let i = (y.get(r) ?? 0) + 1;
+			if (t === void 0) {
+				let e = n && E.entries.get(C(n));
+				return e ? e.line + 1 : i;
+			}
+			let a = r.steps.find((e) => e.id === t), o = a && _.get(a);
+			if (!a || !o) return;
+			let s = n && x.get(a)?.entries.get(C(n));
+			return s ? s.line + 1 : o.start;
+		}
+	};
+}, F = (e, t = {}) => {
+	try {
+		return P(e, t);
+	} catch (e) {
+		return {
+			lesson: { chapters: [] },
+			issues: [{
+				rule: "parser-failure",
+				severity: "error",
+				message: `The lesson file could not be parsed: ${String(e)}`,
+				line: 1
+			}],
+			srcPaths: [],
+			locate: () => void 0
+		};
+	}
+};
+//#endregion
+export { F as parseLesson };

package/dist/src/App.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/callouts.d.ts

@@ -0,0 +1,28 @@
+import { type AlertVariants } from '@karagoz/shared';
+import type { PluginSimple } from 'markdown-it';
+export interface CalloutDefinition {
+    variant: NonNullable<AlertVariants['variant']>;
+}
+export interface CalloutRegistry {
+    /** Registers (or replaces) a callout kind, e.g. `:::tip`. */
+    register: (kind: string, definition: CalloutDefinition) => void;
+    get: (kind: string) => CalloutDefinition | undefined;
+}
+export declare const defaultCallouts: Record<string, CalloutDefinition>;
+export declare function createCalloutRegistry(initial?: Record<string, CalloutDefinition>): CalloutRegistry;
+/** Splits a container info string (`tip Custom title`) into kind and optional title. */
+export declare function parseCalloutInfo(info: string): {
+    kind: string;
+    title: string;
+};
+/**
+ * Pure transform: callout info string → opening HTML using the shared Alert
+ * styling, or `undefined` when the kind is not registered.
+ */
+export declare function renderCalloutOpen(registry: CalloutRegistry, info: string, escape: (text: string) => string): string | undefined;
+export declare const CALLOUT_CLOSE_HTML = "</div></div>";
+/**
+ * markdown-it plugin recognising `:::kind [title]` ... `:::` blocks for every
+ * kind in the registry. Unregistered kinds are left as plain markdown.
+ */
+export declare function calloutPlugin(registry: CalloutRegistry): PluginSimple;

package/dist/src/components/KrgzHayali.vue.d.ts

@@ -0,0 +1,49 @@
+import type { FullLayoutFrom } from '../layout/breakpoints';
+import type { Lesson, Position } from '../types';
+type __VLS_Props = {
+    lesson: Lesson;
+    /**
+     * Minimum container width for the side-by-side lesson/sandbox split; below it a single panel is shown
+     * with a Lesson/Sandbox toggle. Uses the component's own width (container query), not the viewport's.
+     * `none` always uses the single-panel layout.
+     * **Available values:** none, xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl, 6xl, 7xl
+     */
+    fullLayoutFrom?: FullLayoutFrom;
+    /**
+     * Forwarded to the default `KrgzSandbox` (and exposed on the `sandbox` slot) as its `multi-panel-from`,
+     * so the sandbox drops to a single panel when its pane is narrow.
+     * **Available values:** none, xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl, 6xl, 7xl
+     */
+    multiPanelFrom?: FullLayoutFrom;
+};
+type __VLS_ModelProps = {
+    /**
+     * Current step. Optional so a server render needs nothing from the consumer: it falls back to the first step of the
+     * first chapter (never restored from `localStorage`).
+     */
+    'position'?: Position;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_55: {
+    ready: boolean;
+    multiPanelFrom: FullLayoutFrom;
+};
+type __VLS_Slots = {} & {
+    sandbox?: (props: typeof __VLS_55) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:position": (value: Position | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:position"?: ((value: Position | undefined) => any) | undefined;
+}>, {
+    fullLayoutFrom: FullLayoutFrom;
+    multiPanelFrom: FullLayoutFrom;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/LessonToolbar.vue.d.ts

@@ -0,0 +1,17 @@
+import type { StepGroup } from '../composables/useLessonPosition';
+import type { Position } from '../types';
+type __VLS_Props = {
+    prev?: Position;
+    next?: Position;
+    groups: StepGroup[];
+    current: Position;
+    chapterTitle?: string;
+    disabled?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    navigate: (position: Position) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNavigate?: ((position: Position) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/StepBody.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    /** Step markdown body. */
+    body: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/StepList.vue.d.ts

@@ -0,0 +1,15 @@
+import type { PathPattern, Step } from '../types';
+type __VLS_Props = {
+    steps: Step[];
+    currentStepId: string;
+    /** Lock patterns of the current step. */
+    locks: PathPattern[];
+    disabled?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (stepId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((stepId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/StepLockAlert.vue.d.ts

@@ -0,0 +1,8 @@
+import type { PathPattern } from '../types';
+type __VLS_Props = {
+    /** Lock patterns of the current step. */
+    locks: PathPattern[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/TocDropdown.vue.d.ts

@@ -0,0 +1,14 @@
+import type { StepGroup } from '../composables/useLessonPosition';
+import type { Position } from '../types';
+type __VLS_Props = {
+    groups: StepGroup[];
+    current: Position;
+    disabled?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (position: Position) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((position: Position) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/composables/useCounter.d.ts

@@ -0,0 +1,4 @@
+export declare function useCounter(initial?: number): {
+    count: import("vue").Ref<number, number>;
+    increment: () => void;
+};

package/dist/src/composables/useIsolationWarning.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Logs one dev-mode warning when the page isn't cross-origin isolated: WebContainer needs it, and without it the
+ * sandbox can't boot. Call from a mounted hook (never on the server).
+ */
+export declare const warnIfNotIsolated: () => void;