@topik/core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Topik Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -1,20 +1,12 @@
 import { z } from "zod";
-import { Guide, Wiki, WikiPage } from "@topik/schema";
+import { Asset, Guide, Wiki, WikiPage } from "@topik/schema";
 
 //#region src/config/collection.d.ts
 declare const collectionConfigSchema: z.ZodObject<{
   id: z.ZodString;
   title: z.ZodString;
-  tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-  id: string;
-  title: string;
-  tags?: string[] | undefined;
-}, {
-  id: string;
-  title: string;
-  tags?: string[] | undefined;
-}>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 type CollectionConfig = z.infer<typeof collectionConfigSchema>;
 declare function parseCollectionConfig(raw: unknown): CollectionConfig;
 //#endregion
@@ -37,81 +29,27 @@ type WikiNavNode = string | {
 declare const wikiConfigSchema: z.ZodObject<{
   id: z.ZodString;
   title: z.ZodString;
-  navigation: z.ZodOptional<z.ZodArray<z.ZodType<WikiNavNode, z.ZodTypeDef, unknown>, "many">>;
+  navigation: z.ZodOptional<z.ZodArray<z.ZodType<WikiNavNode, unknown, z.core.$ZodTypeInternals<WikiNavNode, unknown>>>>;
   theme: z.ZodOptional<z.ZodObject<{
     colors: z.ZodOptional<z.ZodObject<{
       primary: z.ZodString;
       light: z.ZodOptional<z.ZodString>;
       dark: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    }, {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     appearance: z.ZodOptional<z.ZodObject<{
-      default: z.ZodOptional<z.ZodEnum<["light", "dark", "system"]>>;
-    }, "strip", z.ZodTypeAny, {
-      default?: "dark" | "light" | "system" | undefined;
-    }, {
-      default?: "dark" | "light" | "system" | undefined;
-    }>>;
-  }, "strip", z.ZodTypeAny, {
-    colors?: {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    } | undefined;
-    appearance?: {
-      default?: "dark" | "light" | "system" | undefined;
-    } | undefined;
-  }, {
-    colors?: {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    } | undefined;
-    appearance?: {
-      default?: "dark" | "light" | "system" | undefined;
-    } | undefined;
-  }>>;
-}, "strip", z.ZodTypeAny, {
-  id: string;
-  title: string;
-  navigation?: WikiNavNode[] | undefined;
-  theme?: {
-    colors?: {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    } | undefined;
-    appearance?: {
-      default?: "dark" | "light" | "system" | undefined;
-    } | undefined;
-  } | undefined;
-}, {
-  id: string;
-  title: string;
-  navigation?: unknown[] | undefined;
-  theme?: {
-    colors?: {
-      primary: string;
-      light?: string | undefined;
-      dark?: string | undefined;
-    } | undefined;
-    appearance?: {
-      default?: "dark" | "light" | "system" | undefined;
-    } | undefined;
-  } | undefined;
-}>;
+      default: z.ZodOptional<z.ZodEnum<{
+        dark: "dark";
+        light: "light";
+        system: "system";
+      }>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
 type WikiConfig = z.infer<typeof wikiConfigSchema>;
 declare function parseWikiConfig(raw: unknown): WikiConfig;
 //#endregion
 //#region src/resource.d.ts
-type Resource = Guide | Wiki | WikiPage;
+type Resource = Asset | Guide | Wiki | WikiPage;
 type ResourceType = Resource["type"];
 //#endregion
 //#region src/compile/shared.d.ts

package/dist/index.mjs

@@ -1,10 +1,12 @@
 import { z } from "zod";
-import { join, resolve } from "node:path";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { access, readFile, readdir } from "node:fs/promises";
 import { parse } from "yaml";
+import { createHash } from "node:crypto";
+import Markdoc from "@markdoc/markdoc";
 import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";
-import { guideSchema, wikiPageSchema, wikiSchema } from "@topik/schema";
+import { assetSchema, guideSchema, wikiPageSchema, wikiSchema } from "@topik/schema";
 import { EventEmitter } from "node:events";
 import { watch as watch$1 } from "chokidar";
 //#region src/config/collection.ts
@@ -91,6 +93,195 @@ async function findConfigFile(dir, candidates) {
 	return null;
 }
 //#endregion
+//#region src/compile/assets.ts
+const MIME_BY_EXT = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".ico": "image/x-icon",
+	".bmp": "image/bmp",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".tar": "application/x-tar",
+	".gz": "application/gzip",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+	".ogg": "audio/ogg",
+	".m4a": "audio/mp4",
+	".flac": "audio/flac",
+	".csv": "text/csv",
+	".txt": "text/plain",
+	".doc": "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".xls": "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".ppt": "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+const ASSET_TAG_ATTRS = ["src", "href"];
+async function extractAssets(source, options) {
+	const { baseDir, filePath } = options;
+	const ast = Markdoc.parse(source);
+	const refs = /* @__PURE__ */ new Map();
+	const slots = /* @__PURE__ */ new Map();
+	const collect = (url, slot, requireKnownExtension) => {
+		if (!isLocalRef(url)) return;
+		if (requireKnownExtension && !hasKnownAssetExtension(url)) return;
+		if (!refs.has(url)) {
+			const absPath = resolveAssetPath(url, {
+				baseDir,
+				filePath
+			});
+			const relFromBase = relative(baseDir, absPath).split(sep).join(posix.sep);
+			refs.set(url, {
+				original: url,
+				absPath,
+				relFromBase
+			});
+		}
+		const list = slots.get(url) ?? [];
+		list.push(slot);
+		slots.set(url, list);
+	};
+	walk(ast, (node) => {
+		if (node.type === "image") {
+			const url = stringAttr(node, "src");
+			if (url) collect(url, {
+				node,
+				attr: "src"
+			}, false);
+		} else if (node.type === "link") {
+			const url = stringAttr(node, "href");
+			if (url) collect(url, {
+				node,
+				attr: "href"
+			}, true);
+		} else if (node.type === "tag") for (const attr of ASSET_TAG_ATTRS) {
+			const url = stringAttr(node, attr);
+			if (url) collect(url, {
+				node,
+				attr
+			}, true);
+		}
+	});
+	if (refs.size === 0) return {
+		content: source,
+		assets: [],
+		manifest: []
+	};
+	const urlToId = /* @__PURE__ */ new Map();
+	const byName = /* @__PURE__ */ new Map();
+	const refList = Array.from(refs.values());
+	const settled = await Promise.allSettled(refList.map((ref) => toAsset(ref)));
+	const failures = [];
+	for (let i = 0; i < settled.length; i++) {
+		const result = settled[i];
+		if (result.status === "fulfilled") {
+			urlToId.set(refList[i].original, result.value.name);
+			byName.set(result.value.name, result.value);
+		} else failures.push(result.reason instanceof Error ? result.reason.message : String(result.reason));
+	}
+	if (failures.length > 0) throw new Error(`Failed to extract ${failures.length} asset(s):\n  - ${failures.join("\n  - ")}`);
+	const manifest = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of refs.values()) {
+		const name = urlToId.get(ref.original);
+		if (name && !seen.has(name)) {
+			manifest.push(name);
+			seen.add(name);
+		}
+	}
+	for (const [url, slotList] of slots.entries()) {
+		const id = urlToId.get(url);
+		if (!id) continue;
+		for (const slot of slotList) slot.node.attributes[slot.attr] = `asset:${id}`;
+	}
+	return {
+		content: Markdoc.format(ast),
+		assets: Array.from(byName.values()),
+		manifest
+	};
+}
+function walk(node, fn) {
+	fn(node);
+	for (const child of node.children) walk(child, fn);
+}
+function stringAttr(node, attr) {
+	const value = node.attributes?.[attr];
+	return typeof value === "string" ? value : void 0;
+}
+function hasKnownAssetExtension(url) {
+	const [path] = splitUrl(url);
+	const decoded = decodeSafe(path);
+	const m = /\.([a-z0-9]+)$/i.exec(decoded);
+	if (!m) return false;
+	return `.${m[1].toLowerCase()}` in MIME_BY_EXT;
+}
+function isLocalRef(url) {
+	if (url.length === 0) return false;
+	if (url.startsWith("#")) return false;
+	if (url.startsWith("mailto:")) return false;
+	if (url.startsWith("tel:")) return false;
+	if (url.startsWith("data:")) return false;
+	if (url.startsWith("//")) return false;
+	if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return false;
+	return true;
+}
+function resolveAssetPath(url, { baseDir, filePath }) {
+	const [pathPart] = splitUrl(url);
+	const decoded = decodeSafe(pathPart);
+	const absolute = resolve(isAbsolute(decoded) || decoded.startsWith("/") ? baseDir : dirname(filePath), decoded.replace(/^\/+/, ""));
+	const rel = relative(baseDir, absolute);
+	if (rel.startsWith("..") || isAbsolute(rel)) throw new Error(`Asset reference "${url}" in ${filePath} resolves outside the compilation directory`);
+	return absolute;
+}
+function splitUrl(url) {
+	const hashIdx = url.indexOf("#");
+	const queryIdx = url.indexOf("?");
+	let cut = -1;
+	if (hashIdx >= 0) cut = hashIdx;
+	if (queryIdx >= 0 && (cut < 0 || queryIdx < cut)) cut = queryIdx;
+	if (cut < 0) return [url, ""];
+	return [url.slice(0, cut), url.slice(cut)];
+}
+function decodeSafe(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+}
+async function toAsset(ref) {
+	let bytes;
+	try {
+		bytes = await readFile(ref.absPath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Asset "${ref.original}" not found at ${ref.absPath}: ${message}`, { cause: error });
+	}
+	const digest = createHash("sha256").update(bytes).digest();
+	const integrity = `sha256-${digest.toString("base64")}`;
+	const name = digest.toString("hex").slice(0, 16);
+	const extMatch = /\.([a-z0-9]+)(?:[?#].*)?$/i.exec(ref.relFromBase);
+	const mediaType = MIME_BY_EXT[extMatch ? `.${extMatch[1].toLowerCase()}` : ""];
+	return {
+		apiVersion: "v1",
+		type: "Asset",
+		name,
+		spec: {
+			uri: ref.relFromBase,
+			integrity,
+			...mediaType ? { mediaType } : {}
+		}
+	};
+}
+//#endregion
 //#region src/compile/shared.ts
 const DNS_LABEL_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function parseMarkdownFrontmatter(raw, filePath) {
@@ -143,15 +334,26 @@ async function compileWiki(options) {
 	if (raw == null) return { resources: [] };
 	const config = parseWikiConfig(raw);
 	const pagePaths = config.navigation ? [...new Set(collectPagePaths(config.navigation))] : [];
-	const fileContents = await Promise.all(pagePaths.map(async (pagePath) => {
-		return readFile(await resolveFilePath(dir, pagePath), "utf-8");
+	const resolvedFiles = await Promise.all(pagePaths.map(async (pagePath) => {
+		const filePath = await resolveFilePath(dir, pagePath);
+		return {
+			filePath,
+			raw: await readFile(filePath, "utf-8")
+		};
 	}));
 	const resources = [];
+	const assetsById = /* @__PURE__ */ new Map();
 	for (let i = 0; i < pagePaths.length; i++) {
 		const pagePath = pagePaths[i];
-		const { frontmatter, content } = parseMarkdownFrontmatter(fileContents[i], pagePath);
+		const { filePath, raw } = resolvedFiles[i];
+		const { frontmatter, content } = parseMarkdownFrontmatter(raw, pagePath);
+		const { content: rewritten, assets, manifest } = await extractAssets(content, {
+			baseDir: dir,
+			filePath
+		});
+		for (const asset of assets) if (!assetsById.has(asset.name)) assetsById.set(asset.name, asset);
 		const name = pagePathToName(pagePath);
-		const title = typeof frontmatter.title === "string" ? frontmatter.title : extractMarkdownTitle(content, name);
+		const title = typeof frontmatter.title === "string" ? frontmatter.title : extractMarkdownTitle(rewritten, name);
 		const pageResource = {
 			apiVersion: "v1",
 			type: "WikiPage",
@@ -161,12 +363,14 @@ async function compileWiki(options) {
 				title,
 				content: {
 					format: "topik",
-					value: content
-				}
+					value: rewritten
+				},
+				...manifest.length > 0 ? { assets: manifest } : {}
 			}
 		};
 		resources.push(pageResource);
 	}
+	for (const asset of assetsById.values()) resources.push(asset);
 	const wikiResource = {
 		apiVersion: "v1",
 		type: "Wiki",
@@ -242,11 +446,18 @@ async function compileGuides(options) {
 	const config = parseCollectionConfig(raw);
 	const markdownFiles = (await readdir(dir)).filter((f) => f.endsWith(".md") || f.endsWith(".mdx")).sort();
 	const resources = [];
+	const assetsById = /* @__PURE__ */ new Map();
 	for (const file of markdownFiles) {
-		const { frontmatter, content } = parseMarkdownFrontmatter(await readFile(join(dir, file), "utf-8"), file);
+		const filePath = join(dir, file);
+		const { frontmatter, content } = parseMarkdownFrontmatter(await readFile(filePath, "utf-8"), file);
+		const { content: rewritten, assets, manifest } = await extractAssets(content, {
+			baseDir: dir,
+			filePath
+		});
+		for (const asset of assets) if (!assetsById.has(asset.name)) assetsById.set(asset.name, asset);
 		const slug = fileToSlug(file);
 		const name = `${config.id}-${slug}`;
-		const title = typeof frontmatter.title === "string" ? frontmatter.title : extractMarkdownTitle(content, slug);
+		const title = typeof frontmatter.title === "string" ? frontmatter.title : extractMarkdownTitle(rewritten, slug);
 		const tags = mergeTags(config.tags, frontmatter.tags);
 		const authors = parseReferenceList(frontmatter.authors, "authors", file);
 		const description = typeof frontmatter.description === "string" ? frontmatter.description : void 0;
@@ -262,12 +473,14 @@ async function compileGuides(options) {
 				...tags.length > 0 ? { tags } : {},
 				content: {
 					format: "topik",
-					value: content
-				}
+					value: rewritten
+				},
+				...manifest.length > 0 ? { assets: manifest } : {}
 			}
 		};
 		resources.push(guide);
 	}
+	for (const asset of assetsById.values()) resources.push(asset);
 	return { resources };
 }
 function fileToSlug(filename) {
@@ -314,6 +527,7 @@ const ajv = new Ajv2020({
 });
 addFormats(ajv);
 const validators = {
+	Asset: ajv.compile(assetSchema),
 	Guide: ajv.compile(guideSchema),
 	Wiki: ajv.compile(wikiSchema),
 	WikiPage: ajv.compile(wikiPageSchema)

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@topik/core",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "description": "Topik core library",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/subtopik/topik.git",
+    "directory": "packages/core"
+  },
   "files": [
     "dist"
   ],
@@ -14,26 +19,26 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "vp pack",
-    "dev": "vp pack --watch",
-    "test": "vp test",
-    "check": "vp check",
-    "prepublishOnly": "vp run build"
-  },
   "dependencies": {
-    "@topik/schema": "workspace:*",
-    "ajv": "^8.18.0",
+    "@markdoc/markdoc": "^0.5.7",
+    "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
-    "chokidar": "^4.0.0",
-    "yaml": "^2.7.0",
-    "zod": "^3.25.0"
+    "chokidar": "^5.0.0",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6",
+    "@topik/schema": "0.1.0-alpha.3"
   },
   "devDependencies": {
-    "@types/node": "catalog:",
-    "@typescript/native-preview": "catalog:",
-    "typescript": "catalog:",
-    "vite-plus": "catalog:",
-    "vitest": "catalog:"
+    "@types/node": "^24",
+    "@typescript/native-preview": "7.0.0-dev.20260427.1",
+    "typescript": "^6",
+    "vite-plus": "^0.1.18",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
   }
-}
+}