@spicetify/kit 0.4.3 → 0.4.4

package/dist/push.js

@@ -12,6 +12,7 @@
  */
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
+import { KIND_OF_META_SOURCE } from "./vault-metadata.js";
 // localStorage quota is ~5 MB for the xpui origin, shared with Spotify's own
 // keys and other local modules, so thresholds are conservative. Counted in
 // UTF-16 code units (JSON.stringify(...).length), the unit the quota counts.
@@ -257,8 +258,8 @@ export function pushExpression(rec, id, nonce, stamped) {
 		if (reenabled) await (M.reload ?? M.enable)(id);
 		// Re-enabling a theme the loader just unloaded would fight the
 		// single-active-theme invariant and knock the pushed theme back off.
-		// metadata.json says "kind"; modules published before it carry "tags".
-		const themed = (meta) => meta?.kind === "theme" || (meta?.tags ?? []).includes("theme");
+		const kindOf = ${KIND_OF_META_SOURCE};
+		const themed = (meta) => kindOf(meta) === "theme";
 		const pushedIsTheme = themed(rec.metadata);
 		const isTheme = (mid) => themed(M.manifest?.modules?.find((m) => m.identifier === mid));
 		for (const other of before) {

package/dist/stdlib-boundary.js

@@ -4,6 +4,7 @@
  */
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
+import { kindOfMeta } from "./vault-metadata.js";
 export const STDLIB_BOUNDARY_WARNING_RULES = ["ambient-client", "client-dom", "direct-map"];
 const SOURCE_EXTENSIONS = new Set([".js", ".jsx", ".mjs", ".ts", ".tsx"]);
 const STYLE_EXTENSIONS = new Set([".css", ".scss"]);
@@ -202,7 +203,7 @@ export function checkExternalStdlibBoundary(root, metadata) {
     const entries = meta.entries;
     if (typeof entries?.js !== "string" || meta.name === "stdlib")
         return out;
-    const isTheme = meta.kind === "theme" || (Array.isArray(meta.tags) && meta.tags.some((tag) => tag === "theme"));
+    const isTheme = kindOfMeta(meta) === "theme";
     const dependencies = meta.dependencies;
     const missingDependency = !isTheme &&
         typeof dependencies === "object" &&

package/dist/vault-metadata.js

@@ -12,6 +12,14 @@ export const kindOfMeta = (meta) => {
     const tags = Array.isArray(meta.tags) ? meta.tags : [];
     return KINDS.find((kind) => tags.includes(kind));
 };
+// kindOfMeta as JavaScript source, for expressions evaluated inside the
+// client where kit code cannot be imported. It also accepts a missing meta.
+export const KIND_OF_META_SOURCE = `((meta) => {
+	const kinds = ${JSON.stringify(KINDS)};
+	if (typeof meta?.kind === "string" && kinds.includes(meta.kind)) return meta.kind;
+	const tags = Array.isArray(meta?.tags) ? meta.tags : [];
+	return kinds.find((kind) => tags.includes(kind));
+})`;
 // metadata.json authors are plain names; author objects (with a github)
 // pass through, so an artifact may declare either.
 const normalizeAuthors = (authors) => authors.flatMap((a) => {

package/dist/version.js

@@ -4,5 +4,5 @@
  */
 // Kept in lockstep with package.json by release-please. Scaffolds must depend
 // on the kit version that generated them, especially across pre-1.0 minors.
-export const KIT_VERSION = "0.4.3"; // x-release-please-version
+export const KIT_VERSION = "0.4.4"; // x-release-please-version
 export const KIT_DEPENDENCY_RANGE = `^${KIT_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@spicetify/kit",
-	"version": "0.4.3",
+	"version": "0.4.4",
 	"description": "Developer kit for spicetify v3 modules: scaffold, build, hot-push, and pack",
 	"license": "GPL-3.0-or-later",
 	"homepage": "https://github.com/spicetify/modules#readme",
@@ -40,7 +40,7 @@
 		"access": "public"
 	},
 	"spicetify": {
-		"stdlibVersion": "1.13.1"
+		"stdlibVersion": "1.13.2"
 	},
 	"scripts": {
 		"build": "tsc -p tsconfig.build.json",

package/vendor/stdlib/metadata.json

@@ -3,7 +3,7 @@
 	"kind": "lib",
 	"hidden": true,
 	"preview": "./assets/PREVIEW.png",
-	"version": "1.13.1",
+	"version": "1.13.2",
 	"compat": ["0.3.0"],
 	"authors": ["spicetify", "Delusoire"],
 	"description": "The standard library",

package/vendor/stdlib/src/util.ts

@@ -14,9 +14,10 @@ type Predicate<A> = (value: A) => boolean;
 
 // Some client exports are functions whose own toString is not callable;
 // they can never match a needle, so they stringify to "".
-const safeString = (x: any): string => {
+const stringify = (x: any): string => {
+	if (x == null) return "";
 	try {
-		return x.toString();
+		return String(x);
 	} catch {
 		try {
 			return Function.prototype.toString.call(x);
@@ -26,18 +27,32 @@ const safeString = (x: any): string => {
 	}
 };
 
+const sources = new WeakMap<object, string>();
+
+// sourceOf is the source text needles match against, computed once per
+// function or object for the whole session.
+export const sourceOf = (x: unknown): string => {
+	if ((typeof x !== "object" && typeof x !== "function") || x === null) return stringify(x);
+	let source = sources.get(x);
+	if (source === undefined) {
+		source = stringify(x);
+		sources.set(x, source);
+	}
+	return source;
+};
+
 export function findBy(...tests: Array<string | RegExp | Predicate<any>>) {
 	const testFns = tests.map((test): Predicate<any> => {
 		switch (typeof test) {
 			case "string":
-				return (x) => safeString(x).includes(test);
+				return (x) => sourceOf(x).includes(test);
 			case "function":
 				return (x) => test(x);
 			default: // assume regex
-				return (x) => test.test(safeString(x));
+				return (x) => test.test(sourceOf(x));
 		}
 	});
-	const testFn = (x: any) => testFns.map((t) => t(x)).every(Boolean);
+	const testFn = (x: any) => testFns.every((t) => t(x));
 	return <A>(xs: A[]) => xs.find(testFn)!;
 }
 

package/vendor/stdlib/src/webpack/ComponentLibrary.xpui.ts

@@ -10,9 +10,19 @@ await CHUNKS.xpui.promise;
 const componentNames = Object.keys(
 	exported.find((e) => e.BrowserDefaultFocusStyleProvider && Object.hasOwn(e, "BrowserDefaultFocusStyleProvider")),
 );
-const componentRegexes = componentNames.map((n) => new RegExp(`"data-encore-id":(?:[a-zA-Z_\$][\w\$]*\\.){2}${n}\\b`));
+const componentRegexes = componentNames.map(
+	(n) => new RegExp(String.raw`"data-encore-id":(?:[a-zA-Z_$][\w$]*\.){2}${n}\b`),
+);
 const componentPairs = [exportedFunctions.map((f) => [f, f]), exportedForwardRefs.map((f) => [(f as any).render, f])]
 	.flat()
-	.map(([s, f]) => [componentNames.find((n, i) => src(s).match(componentRegexes[i])), f]);
+	.map(([s, f]) => {
+		const code = src(s);
+		return [
+			code.includes('"data-encore-id"')
+				? componentNames.find((_, i) => componentRegexes[i].test(code))
+				: undefined,
+			f,
+		];
+	});
 
 export const UI: any = Object.fromEntries(componentPairs);

package/vendor/stdlib/src/webpack/index.ts

@@ -4,8 +4,10 @@
  */
 
 import { warn } from "../logger.ts";
+import { sourceOf } from "../util.ts";
 import { postWebpackRequireHooks, WebpackModule, WebpackRequire, webpackRequire } from "../wpunpk.mix.ts";
 import { createCaptureReadiness } from "./capture-readiness.ts";
+import { watchRegistryQuiet } from "./registry-quiet.ts";
 
 export let modules: Array<[PropertyKey, WebpackModule]>;
 export let exports: Array<Record<string, any>>;
@@ -18,19 +20,7 @@ export let exportedContexts: Array<React.Context<any>>;
 export let exportedForwardRefs: Array<any>;
 export let exportedMemos: React.NamedExoticComponent[];
 
-// Some client exports are functions whose own toString is not callable; they
-// can never match a needle, so they stringify to "".
-export const src = (f: unknown): string => {
-	try {
-		return String(f);
-	} catch {
-		try {
-			return Function.prototype.toString.call(f);
-		} catch {
-			return "";
-		}
-	}
-};
+export const src = sourceOf;
 
 export const analyzeWebpackRequire = (webpackRequire: WebpackRequire) => {
 	const modules = Object.entries(webpackRequire.m) as Array<[keyof any, WebpackModule]>;
@@ -84,18 +74,31 @@ Object.assign(CHUNKS, {
 // executed by capture time. Lazy route chunks go through the runtime's own
 // script loader (wpr.l) from then on.
 postWebpackRequireHooks.push((wpr: any) => {
+	let loading = 0;
 	if (typeof wpr?.l === "function") {
 		const load = wpr.l.bind(wpr);
-		wpr.l = (url: string, done: (event: unknown) => unknown, key?: string, chunkId?: unknown) =>
-			load(
-				url,
-				(event: unknown) => {
-					resolveChunk(new URL(url, location.href).pathname);
-					return done(event);
-				},
-				key,
-				chunkId,
-			);
+		wpr.l = (url: string, done: (event: unknown) => unknown, key?: string, chunkId?: unknown) => {
+			loading++;
+			try {
+				return load(
+					url,
+					(event: unknown) => {
+						loading--;
+						try {
+							resolveChunk(new URL(url, location.href).pathname);
+						} catch (error) {
+							console.error(`[stdlib] could not resolve chunk ${url}:`, error);
+						}
+						return done(event);
+					},
+					key,
+					chunkId,
+				);
+			} catch (error) {
+				loading--;
+				throw error;
+			}
+		};
 	}
 	// Chunk scripts that finished loading before capture. The xpui entry
 	// chunks are deliberately excluded: they are gated below on registry
@@ -108,23 +111,18 @@ postWebpackRequireHooks.push((wpr: any) => {
 		}
 	}
 	// Capture can fire while boot is still registering modules (xpui-modules
-	// and friends land after the runtime is up, and the analysis needles live
-	// there). The analysis below snapshots wpr.m once, so hold the xpui
-	// promises until the registry has been quiet for a few ticks — with a
-	// hard cap so a pathological boot still resolves.
-	let last = -1;
-	let stable = 0;
-	let ticks = 0;
-	const settle = setInterval(() => {
-		const count = Object.keys(wpr?.m ?? {}).length;
-		stable = count === last ? stable + 1 : 0;
-		last = count;
-		if (stable >= 3 || ++ticks > 100) {
-			clearInterval(settle);
+	// and the lazy chunks the client requests right after it land later, and
+	// analysis needles such as GenericModal live there). The analysis below
+	// snapshots wpr.m once, so hold the xpui promises until the registry has
+	// been quiet, with no chunk in flight, for 300ms.
+	watchRegistryQuiet(
+		() => Object.keys(wpr?.m ?? {}).length,
+		() => loading,
+		() => {
 			resolveChunk("/vendor~xpui.js");
 			resolveChunk("/xpui.js");
-		}
-	}, 100);
+		},
+	);
 });
 
 // Capture subscribers run synchronously right after the analysis lands, so
@@ -135,7 +133,7 @@ postWebpackRequireHooks.push((wpr: any) => {
 let captured = false;
 const captureSubscribers: Array<() => void> = [];
 const webpackCaptureReadiness = createCaptureReadiness({
-	// Registry quiescence caps at about 10.1s. Leave room for its last tick,
+	// Registry quiescence caps at about 10s. Leave room for its last tick,
 	// then release degraded so a changed runtime cannot deadlock all modules.
 	timeoutMs: 12000,
 	onTimeout: () => warn("[stdlib] capture health: webpack capture timed out; module surfaces will be degraded"),

package/vendor/stdlib/src/webpack/registry-quiet.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2026 Afonso Jorge Ramos
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+const QUIET_MS = 300;
+const TICK_MS = 25;
+const CAP_MS = 10_000;
+
+// watchRegistryQuiet calls onQuiet once the module registry has not changed,
+// and no chunk load has been in flight, for 300ms. A 10s cap bounds the wait
+// so a chunk that never finishes, or a registry that never settles, still
+// resolves.
+export function watchRegistryQuiet(count: () => number, pending: () => number, onQuiet: () => void): void {
+	const started = Date.now();
+	let last = -1;
+	let quietSince = started;
+	const timer = setInterval(() => {
+		const current = count();
+		const at = Date.now();
+		if (current !== last || pending() > 0) {
+			last = current;
+			quietSince = at;
+		}
+		if (at - quietSince >= QUIET_MS || at - started >= CAP_MS) {
+			clearInterval(timer);
+			onQuiet();
+		}
+	}, TICK_MS);
+}