@glissade/cli 0.32.0 → 0.33.0

package/README.md

@@ -2,6 +2,8 @@
 
 `gs` — headless rendering and the dev/capture loop. `gs render` evaluates every frame, rasterizes on Skia (no browser anywhere), writes a PNG sequence or muxes mp4/webm via FFmpeg with sample-accurate audio. v2: `gs dev --record` serves a scene with its state machines mounted and writes input-trace sidecars; `gs render --trace/--state` are the deterministic export routes for interactive scenes.
 
+The full command set: `render`, `dev`, `import` (Lottie `.json` / `.svg`), `build`, `mcp` (an MCP server over the engine), `describe`, `migrate`, `narrate`, `sfx`, `prepare`, `measure-loudness`, `fonts`, `cache`, `diff`, and `verify-determinism`.
+
 ```sh
 npm i -D @glissade/cli
 ```

package/dist/build.js

@@ -72,18 +72,55 @@ var build_exports = /* @__PURE__ */ __exportAll({
 	defineProject: () => defineProject,
 	hashInputs: () => hashInputs,
 	loadConfig: () => loadConfig,
+	mixDefaults: () => mixDefaults,
 	outputVideo: () => outputVideo,
+	renderDefaults: () => renderDefaults,
 	resolveScenes: () => resolveScenes,
 	stepInputs: () => stepInputs,
-	stepOutput: () => stepOutput
+	stepOutput: () => stepOutput,
+	stepSalt: () => stepSalt
 });
+/** The defaults that change a RENDER's output — folded into its staleness hash
+*  (a captions/mix-mode flip must re-run render, never serve a stale cached
+*  master) and spread into the render call. `cache` is deliberately absent
+*  (byte-identical speed knob). */
+function renderDefaults(cfg) {
+	const d = cfg.defaults ?? {};
+	return {
+		...d.fps !== void 0 ? { fps: d.fps } : {},
+		...d.captions !== void 0 ? { captions: d.captions } : {},
+		...d.narration !== void 0 ? { narration: d.narration } : {},
+		...d.music !== void 0 ? { music: d.music } : {},
+		...d.sfx !== void 0 ? { sfx: d.sfx } : {},
+		...d.loudness !== void 0 ? { loudness: d.loudness } : {}
+	};
+}
+/** The mix-mode defaults measure-loudness shares with render (measured mix ==
+*  rendered mix, or render's stale-mixHash guard trips). */
+function mixDefaults(cfg) {
+	const d = cfg.defaults ?? {};
+	return {
+		...d.narration !== void 0 ? { narration: d.narration } : {},
+		...d.music !== void 0 ? { music: d.music } : {},
+		...d.sfx !== void 0 ? { sfx: d.sfx } : {}
+	};
+}
+/** Per-step staleness salt: the engine version PLUS any config options that
+*  change the step's OUTPUT. Options ride the salt (not stepInputs) because
+*  they aren't files; a flipped option changes the hash exactly like an edited
+*  input, so the step re-runs instead of serving a stale artifact. */
+function stepSalt(step, cfg, version) {
+	if (step === "render") return `${version}\0render:${JSON.stringify(renderDefaults(cfg))}`;
+	if (step === "measure-loudness") return `${version}\0mix:${JSON.stringify(mixDefaults(cfg))}`;
+	return version;
+}
 /** Identity helper for a typed `glissade.config.ts` default export. */
 function defineProject(config) {
 	return config;
 }
 async function loadConfig(configPath) {
 	const { createJiti } = await import("jiti");
-	const cfg = await createJiti(pathToFileURL(`${process.cwd()}/`).href).import(pathToFileURL(resolve(configPath)).href, { default: true });
+	const cfg = await createJiti(pathToFileURL(`${process.cwd()}/`).href, { moduleCache: false }).import(pathToFileURL(resolve(configPath)).href, { default: true });
 	if (!cfg || !Array.isArray(cfg.scenes)) throw new Error(`${configPath}: config must default-export { scenes: string[] } — use defineProject({ scenes: [...] })`);
 	return cfg;
 }
@@ -216,7 +253,7 @@ async function buildCommand(opts, deps = { runStep: defaultRunStep }) {
 		const rec = manifest.scenes[key] ?? {};
 		const videoPath = outputVideo(scene, cfg, root);
 		const plans = planScene(key, applicableSteps(scene), {
-			currentHash: (step) => hashInputs(stepInputs(scene, step), version),
+			currentHash: (step) => hashInputs(stepInputs(scene, step), stepSalt(step, cfg, version)),
 			recordedHash: (step) => rec[step],
 			outputExists: (step) => existsSync(stepOutput(scene, step, videoPath))
 		});
@@ -229,7 +266,7 @@ async function buildCommand(opts, deps = { runStep: defaultRunStep }) {
 			ran++;
 			if (!opts.explain) {
 				await deps.runStep(scene, plan.step, cfg, videoPath);
-				rec[plan.step] = hashInputs(stepInputs(scene, plan.step), version);
+				rec[plan.step] = hashInputs(stepInputs(scene, plan.step), stepSalt(plan.step, cfg, version));
 			}
 		}
 		manifest.scenes[key] = rec;
@@ -258,7 +295,10 @@ async function defaultRunStep(scene, step, cfg, videoPath) {
 		}
 		case "measure-loudness": {
 			const { measureLoudnessCommand } = await import("./loudness.js").then((n) => n.c);
-			await measureLoudnessCommand({ modulePath: scene });
+			await measureLoudnessCommand({
+				modulePath: scene,
+				...mixDefaults(cfg)
+			});
 			return;
 		}
 		case "render": {
@@ -266,7 +306,7 @@ async function defaultRunStep(scene, step, cfg, videoPath) {
 			await render({
 				modulePath: scene,
 				out: videoPath,
-				...cfg.defaults?.fps !== void 0 ? { fps: cfg.defaults.fps } : {},
+				...renderDefaults(cfg),
 				...cfg.defaults?.cache ? { cache: {
 					dir: cfg.defaults.cache,
 					mode: "read-write"

package/dist/cli.js

@@ -56,6 +56,13 @@ function fail(msg) {
 	console.error(`gs: ${msg}`);
 	process.exit(1);
 }
+/** Validate --fps: a non-positive fps silently renders the WRONG frame
+*  (t = frame/0 = Infinity clamps to the timeline end) — fail loud instead. */
+function parseFpsOrFail(raw) {
+	const fps = Number(raw);
+	if (!Number.isFinite(fps) || fps <= 0) fail(`--fps must be a positive number, got '${raw}'`);
+	return fps;
+}
 function parseCaptionsModeOrFail(raw) {
 	try {
 		return parseCaptionsMode(raw);
@@ -80,6 +87,7 @@ const USAGE = `usage:
   gs build [filter...] [--config <glissade.config.ts>] [--explain]   content-graph DAG runner: narrate→sfx→loudness→render per scene, runs ONLY the stale subtree
   gs describe [--out <api.json>] [--examples]   snapshot THIS engine's describe() API manifest (stdout, or --out to a file) — the input to gs migrate
   gs migrate <baseline-api.json> [--json]   diff a saved API manifest against the current engine: moved imports / removed / added / changed, with a suggested fix per breaking item (advisory; never rewrites your files)
+  gs --version   print the engine version
 
 render options:
   --out <path>     output directory for a PNG sequence, or .mp4/.webm (needs ffmpeg). default: ./out
@@ -170,6 +178,11 @@ narration-lint options (lint the committed *.narration.timing.json + the real ca
 `;
 async function main() {
 	const [command, ...rest] = process.argv.slice(2);
+	if (command === "--version" || command === "-v" || command === "version") {
+		const { describe } = await import("@glissade/scene/describe");
+		process.stdout.write(`${describe().version}\n`);
+		return;
+	}
 	if (command !== "render" && command !== "diff" && command !== "verify-determinism" && command !== "dev" && command !== "import" && command !== "narrate" && command !== "narration-lint" && command !== "sfx" && command !== "prepare" && command !== "measure-loudness" && command !== "fonts" && command !== "cache" && command !== "mcp" && command !== "build" && command !== "describe" && command !== "migrate") {
 		console.error(USAGE);
 		process.exit(command === void 0 || command === "help" || command === "--help" ? 0 : 1);
@@ -233,7 +246,7 @@ async function main() {
 				modulePath: sceneModule,
 				...cvRange ? { frameRange: cvRange } : {},
 				...sampleFlag !== void 0 ? { sample: Number(sampleFlag) } : {},
-				...cvFpsFlag ? { fps: parseInt(cvFpsFlag, 10) } : {}
+				...cvFpsFlag ? { fps: parseFpsOrFail(cvFpsFlag) } : {}
 			});
 			process.stdout.write(`${result.report}\n`);
 			if (!result.ok) process.exit(1);
@@ -435,7 +448,7 @@ async function main() {
 				...frameRange ? { frameRange } : {},
 				...flags.has("bisect") ? { bisect: true } : {},
 				...flags.has("emit") ? { emit: flags.get("emit") } : {},
-				...fpsFlag ? { fps: parseInt(fpsFlag, 10) } : {}
+				...fpsFlag ? { fps: parseFpsOrFail(fpsFlag) } : {}
 			});
 			process.stdout.write(`${result.report}\n`);
 			if (!result.ok) process.exit(1);
@@ -532,7 +545,7 @@ async function main() {
 		const sharedOpts = {
 			modulePath,
 			out: flags.get("out") ?? "out",
-			...fpsFlag ? { fps: parseInt(fpsFlag, 10) } : {},
+			...fpsFlag ? { fps: parseFpsOrFail(fpsFlag) } : {},
 			...frame !== void 0 ? { frame } : {},
 			...frameRange ? { frameRange } : {},
 			...formatFlag === "png-seq" ? { format: "png-seq" } : {},

package/dist/config.d.ts

@@ -8,9 +8,29 @@ interface ProjectConfig {
   /** per-scene render/cache defaults. */
   defaults?: {
     fps?: number;
+    /** persistent frame-cache dir (speed only — NEVER changes output, so it is
+     *  excluded from the staleness hash). */
     cache?: string;
+    /** captions mode for every render (0.33, consumer-pulled): a series that
+     *  ships SOFT captions sets `captions: 'sidecar'` here — before this, gs
+     *  build always used render's `burn` default and baked captions into the
+     *  masters. Folded into the render staleness hash, so flipping it re-renders. */
+    captions?: 'burn' | 'sidecar' | 'off';
+    /** narration/music/sfx auto-mix modes ('auto' default). Threaded into BOTH
+     *  render and measure-loudness so the measured mix always matches the
+     *  rendered mix (a mismatch would trip render's stale-mixHash guard). */
+    narration?: 'auto' | 'off';
+    music?: 'auto' | 'off';
+    sfx?: 'auto' | 'off';
+    /** apply the committed publish gain at render ('auto' default). */
+    loudness?: 'auto' | 'off';
   };
 }
+/** The defaults that change a RENDER's output — folded into its staleness hash
+ *  (a captions/mix-mode flip must re-run render, never serve a stale cached
+ *  master) and spread into the render call. `cache` is deliberately absent
+ *  (byte-identical speed knob). */
+
 /** Identity helper for a typed `glissade.config.ts` default export. */
 declare function defineProject(config: ProjectConfig): ProjectConfig;
 //#endregion

package/dist/import.js

@@ -29,6 +29,7 @@ async function importCommand(opts) {
 	const inputAbs = resolve(opts.input);
 	const outDir = resolve(opts.out);
 	mkdirSync(outDir, { recursive: true });
+	if (!/\.(svg|json)$/i.test(inputAbs)) throw new Error(`${opts.input}: unsupported input — gs import expects a Lottie .json or an .svg`);
 	if (/\.svg$/i.test(inputAbs)) {
 		let svg;
 		try {

package/dist/index.d.ts

@@ -298,12 +298,6 @@ declare function render(opts: RenderOptions): Promise<{
   frames: number;
   out: string;
 }>;
-/**
- * Collect the timeline + auto-mixed (narration/music/sfx) audio clips for a
- * scene — the shared front half of the mix used by both `planFinalAudio` (the
- * render/shard path) and `buildMixWav` (the measure-loudness path), so the mix
- * CONTENT measured at commit-time is byte-for-byte the mix rendered later.
- */
 declare function collectAudioClips(opts: Pick<RenderOptions, 'modulePath' | 'narration' | 'music' | 'sfx' | 'locale'>, timelineClips: AudioClip[]): Promise<AudioClip[]>;
 /**
  * Resolve the ACTUAL audio files that feed the final mix (timeline clips +

package/dist/layerCache.js

@@ -59,6 +59,7 @@ function decodeEntry(buf) {
 		off += BOUNDS_BYTES;
 	}
 	const raw = inflateSync(buf.subarray(off));
+	if (raw.byteLength !== w * h * 4) throw new Error(`corrupt .gsl layer entry (payload ${raw.byteLength} bytes ≠ ${w}×${h}×4)`);
 	return {
 		rgba: new Uint8ClampedArray(raw.buffer, raw.byteOffset, raw.byteLength),
 		w,

package/dist/loudness.js

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime.js";
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
 //#region src/loudness.ts
 /**
@@ -130,7 +130,9 @@ function peakClampBinds(profile, inputI, inputTp) {
 * hash. The scene module path itself is excluded.
 */
 function computeMixHash(modulePath, extraInputs = []) {
-	const base = modulePath.replace(/\.[jt]sx?$/, "");
+	const abs = resolve(modulePath);
+	const sceneDir = dirname(abs);
+	const base = abs.replace(/\.[jt]sx?$/, "");
 	const siblings = [
 		`${base}.narration.timing.json`,
 		`${base}.music.timing.json`,
@@ -138,7 +140,7 @@ function computeMixHash(modulePath, extraInputs = []) {
 	];
 	const h = createHash("sha256");
 	for (const path of [...siblings, ...extraInputs]) {
-		h.update(path);
+		h.update(relative(sceneDir, resolve(path)));
 		h.update("\0");
 		if (existsSync(path)) h.update(readFileSync(path));
 		else h.update("\0ABSENT\0");

package/dist/mcp.js

@@ -3,6 +3,7 @@ import { t as glissadeVersion } from "./version.js";
 import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { validateTrack } from "@glissade/core";
 import { evaluate } from "@glissade/scene";
 import { SkiaBackend } from "@glissade/backend-skia";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -94,6 +95,24 @@ var McpSession = class McpSession {
 		};
 		const r = applyPatches(this.sidecar, patches, this.baseline);
 		if (r.ok) {
+			for (const p of patches) {
+				if (!("target" in p)) continue;
+				const tlId = "timelineId" in p && typeof p.timelineId === "string" ? p.timelineId : "main";
+				const entry = r.doc.timelines[tlId]?.tracks[p.target];
+				if (entry === void 0) continue;
+				try {
+					validateTrack({
+						target: p.target,
+						type: entry.type,
+						keys: entry.keys.map((k) => ({ ...k }))
+					});
+				} catch (err) {
+					return {
+						ok: false,
+						error: err instanceof Error ? err.message : String(err)
+					};
+				}
+			}
 			this.sidecar = r.doc;
 			this.undoStack.push(r.inverse);
 		}

package/dist/migrate.js

@@ -65,9 +65,11 @@ function diffManifests(from, to) {
 				action: `import { ${name} } from '${toPath}'`
 			});
 		}
-		for (const p of keys(a.props)) {
-			const pa = a.props[p];
-			const pb = b.props[p];
+		const aProps = a.props ?? {};
+		const bProps = b.props ?? {};
+		for (const p of keys(aProps)) {
+			const pa = aProps[p];
+			const pb = bProps[p];
 			if (pa === void 0) continue;
 			if (pb === void 0) {
 				out.push({
@@ -82,12 +84,12 @@ function diffManifests(from, to) {
 			}
 			diffProp(name, p, pa, pb, out);
 		}
-		for (const p of keys(b.props)) if (a.props[p] === void 0) out.push({
+		for (const p of keys(bProps)) if (aProps[p] === void 0) out.push({
 			kind: "added",
 			category: "prop",
 			name: `${name}.${p}`,
 			breaking: false,
-			detail: `new prop (${b.props[p]?.animatable ? "animatable" : "construction-only"})`
+			detail: `new prop (${bProps[p]?.animatable ? "animatable" : "construction-only"})`
 		});
 	}
 	for (const name of keys(toNodes)) if (fromNodes[name] === void 0) {

package/dist/render.js

@@ -269,6 +269,13 @@ async function loadSceneModule(modulePath, locale) {
 		setMessageTable(loadMessageTable(modulePath, locale));
 	} else setMessageTable(void 0);
 	const abs = isAbsolute(modulePath) ? modulePath : resolve(process.cwd(), modulePath);
+	if (![
+		abs,
+		abs.replace(/\.js$/, ".ts"),
+		abs.replace(/\.ts$/, ".js"),
+		`${abs}.ts`,
+		`${abs}.js`
+	].some((c) => existsSync(c))) throw new SceneModuleError(modulePath, "scene module not found (check the path)");
 	const loaded = await createJiti(pathToFileURL(process.cwd() + "/").href).import(pathToFileURL(abs).href, { default: true });
 	if (typeof loaded?.createScene !== "function" || loaded?.timeline === void 0) throw new SceneModuleError(modulePath, "default export is not a SceneModule");
 	return loaded;
@@ -318,8 +325,11 @@ async function render(opts) {
 		lastFrame = Math.max(firstFrame, Math.ceil(to * fps) - 1);
 	}
 	const total = lastFrame - firstFrame + 1;
+	const lastTimelineFrame = Math.max(0, Math.ceil(duration * fps) - 1);
+	if (lastFrame > lastTimelineFrame) process.stderr.write(`warning: frame range ends at ${lastFrame} but the timeline ends at frame ${lastTimelineFrame} (${duration}s @ ${fps}fps) — the ${lastFrame - lastTimelineFrame} extra frame(s) repeat the frozen last frame\n`);
 	const isVideo = opts.format !== "png-seq" && /\.(mp4|webm)$/i.test(opts.out);
 	const singleFile = !isVideo && total === 1 && /\.png$/i.test(opts.out);
+	if (!isVideo && !singleFile && total > 1 && /\.png$/i.test(opts.out)) throw new Error(`--out '${opts.out}' is a .png path but the render covers ${total} frames — pass --frame <n> for one still, or use a directory / .mp4 out`);
 	if (isVideo && !ffmpegAvailable()) throw new Error(`'${opts.out}' needs FFmpeg on PATH and none was found. Render a PNG sequence instead (--out <directory>) or install ffmpeg.`);
 	const workers = Math.max(1, Math.floor(opts.workers ?? 1));
 	if (workers > 1 && isVideo && total > 1) {
@@ -447,6 +457,7 @@ async function render(opts) {
 			encName: enc.name,
 			...enc.note ? { encNote: enc.note } : {}
 		};
+		await resolveLoudnessGainDb(opts, [...compiled.audio]);
 		if (frameCache && keyCtx && opts.cache.mode !== "off") {
 			const prev = readRenderManifest(outAbs);
 			if (prev && existsSync(outAbs)) {
@@ -652,6 +663,12 @@ async function render(opts) {
 * render/shard path) and `buildMixWav` (the measure-loudness path), so the mix
 * CONTENT measured at commit-time is byte-for-byte the mix rendered later.
 */
+const mixNotesSeen = /* @__PURE__ */ new Set();
+function mixNote(line) {
+	if (mixNotesSeen.has(line)) return;
+	mixNotesSeen.add(line);
+	process.stderr.write(`${line}\n`);
+}
 async function collectAudioClips(opts, timelineClips) {
 	const { timingPathFor } = await import("./captions.js").then((n) => n.t);
 	const audioClips = [...timelineClips];
@@ -660,7 +677,7 @@ async function collectAudioClips(opts, timelineClips) {
 		const narrationPath = timingPathFor(opts.modulePath, opts.locale);
 		if (narrationPath) {
 			const voice = buildNarrationClips(narrationPath);
-			if (voice) if (voice.clips.some((c) => bedAlreadyReferenced(audioClips, c.asset.url, opts.modulePath))) process.stderr.write("note: narration already in the timeline audio — auto-mix skipped\n");
+			if (voice) if (voice.clips.some((c) => bedAlreadyReferenced(audioClips, c.asset.url, opts.modulePath))) mixNote("note: narration already in the timeline audio — auto-mix skipped");
 			else {
 				audioClips.push(...voice.clips);
 				process.stderr.write(`note: auto-mixing ${voice.note}\n`);
@@ -671,7 +688,7 @@ async function collectAudioClips(opts, timelineClips) {
 		const musicPath = musicPathFor(opts.modulePath);
 		if (musicPath) {
 			const bed = buildMusicClip(musicPath, timingPathFor(opts.modulePath, opts.locale));
-			if (bed) if (bedAlreadyReferenced(audioClips, bed.clip.asset.url, opts.modulePath)) process.stderr.write("note: music bed already in the timeline audio — auto-mix skipped\n");
+			if (bed) if (bedAlreadyReferenced(audioClips, bed.clip.asset.url, opts.modulePath)) mixNote("note: music bed already in the timeline audio — auto-mix skipped");
 			else {
 				audioClips.push(bed.clip);
 				process.stderr.write(`note: auto-mixing ${bed.note}\n`);
@@ -683,7 +700,7 @@ async function collectAudioClips(opts, timelineClips) {
 		const sfxPath = sfxTimingPathFor(opts.modulePath);
 		if (sfxPath) {
 			const fx = buildSfxClipsFromTiming(sfxPath);
-			if (fx) if (fx.clips.some((c) => bedAlreadyReferenced(audioClips, c.asset.url, opts.modulePath))) process.stderr.write("note: sfx already in the timeline audio — auto-mix skipped\n");
+			if (fx) if (fx.clips.some((c) => bedAlreadyReferenced(audioClips, c.asset.url, opts.modulePath))) mixNote("note: sfx already in the timeline audio — auto-mix skipped");
 			else {
 				audioClips.push(...fx.clips);
 				process.stderr.write(`note: auto-mixing ${fx.note}\n`);
@@ -765,7 +782,7 @@ async function resolveLoudnessGainDb(opts, timelineClips) {
 	if (actual !== measurement.mixHash) {
 		const path = loudnessPathFor(opts.modulePath, opts.locale);
 		const reRun = hasLocale ? `gs measure-loudness ${opts.modulePath} --locale ${opts.locale}` : `gs measure-loudness ${opts.modulePath}`;
-		throw new Error(`loudness: ${path} is stale — the mix inputs changed since it was measured (committed mixHash ${measurement.mixHash.slice(0, 23)}…, current ${actual.slice(0, 23)}…). Re-run \`${reRun}\` (or pass --loudness off to render without normalization).`);
+		throw new Error(`loudness: ${path} is stale — the mix inputs changed since it was measured (committed mixHash ${measurement.mixHash.slice(0, 23)}…, current ${actual.slice(0, 23)}…). Re-run \`${reRun}\` (or pass --loudness off to render without normalization). Note: 0.33 made the mixHash invocation-path-independent — if your mix inputs did NOT change, one re-measure migrates the committed hash.`);
 	}
 	return measurement.gain;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/cli",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "glissade CLI: headless rendering via backend-skia (+ FFmpeg mux).",
   "license": "Apache-2.0",
   "engines": {
@@ -28,15 +28,15 @@
     "@napi-rs/canvas": "^0.1.65",
     "esbuild": "0.28.0",
     "jiti": "^2.4.2",
-    "@glissade/backend-skia": "0.32.0",
-    "@glissade/core": "0.32.0",
-    "@glissade/interact": "0.32.0",
-    "@glissade/lottie": "0.32.0",
-    "@glissade/narrate": "0.32.0",
-    "@glissade/player": "0.32.0",
-    "@glissade/scene": "0.32.0",
-    "@glissade/sfx": "0.32.0",
-    "@glissade/svg": "0.32.0"
+    "@glissade/backend-skia": "0.33.0",
+    "@glissade/core": "0.33.0",
+    "@glissade/interact": "0.33.0",
+    "@glissade/lottie": "0.33.0",
+    "@glissade/narrate": "0.33.0",
+    "@glissade/player": "0.33.0",
+    "@glissade/scene": "0.33.0",
+    "@glissade/sfx": "0.33.0",
+    "@glissade/svg": "0.33.0"
   },
   "repository": {
     "type": "git",