@topik/core 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/preview-C_3OnNUi.d.mts

@@ -0,0 +1,268 @@
+import { TopikGeneratedAssetName } from "@topik/content";
+import { Person } from "@topik/schema/person/v1";
+import { Asset } from "@topik/schema/asset/v1";
+import { Course } from "@topik/schema/course/v1";
+import { CourseModule } from "@topik/schema/course-module/v1";
+import { CoursePage } from "@topik/schema/course-page/v1";
+import { Guide } from "@topik/schema/guide/v1";
+import { Wiki } from "@topik/schema/wiki/v1";
+import { WikiPage } from "@topik/schema/wiki-page/v1";
+//#region src/resource.d.ts
+type Resource = Asset | Course | CourseModule | CoursePage | Guide | Person | Wiki | WikiPage;
+/** Resources accepted as compiler input. `Asset` exists only in compiler output. */
+type SourceResource = Exclude<Resource, Asset>;
+type ResourceType = Resource["type"];
+//#endregion
+//#region src/assets/constants.d.ts
+declare const ASSET_API_VERSION: "v1";
+declare const ASSET_TYPE: "Asset";
+declare const ASSET_SCHEMA_ID: "https://topik.dev/schemas/asset/v1.json";
+declare const TOPIK_JSON_VERSION: "topik-json-v1";
+declare const TOPIK_PATH_VERSION: "topik-path-v1";
+declare const TOPIK_ASSET_REFERENCE_VERSION: "topik-asset-reference-v1";
+declare const TOPIK_MATERIALIZATION_VERSION: "topik-materialization-v1";
+declare const TOPIK_ASSET_NAME_VERSION: "topik-asset-name-v1";
+declare const TOPIK_BLOB_OUTPUT_PREFIX: "blobs";
+declare const TOPIK_PATH_V1_DESCRIPTOR: {
+  readonly collisionNormalization: "toNFKC_Casefold";
+  readonly id: "topik-path-v1";
+  readonly localReferenceEncoding: "rfc3986-utf8-upper-v1";
+  readonly maxComponentUtf8Bytes: 255;
+  readonly maxComponents: 64;
+  readonly maxRepositoryPathUtf8Bytes: 768;
+  readonly normalizationSensitiveExclusion: "unicode-17-new-marks";
+  readonly storageNormalization: "NFC";
+  readonly unicodeVersion: "17.0.0";
+};
+declare const TOPIK_ASSET_LIMITS: {
+  readonly maxDescriptorBytes: 1048576;
+  readonly maxAssetBytes: 268435456;
+  readonly maxAssets: 10000;
+  readonly maxJsonDepth: 8;
+  readonly maxComponentUtf8Bytes: 255;
+  readonly maxComponents: 64;
+  readonly maxRepositoryPathUtf8Bytes: 768;
+};
+//#endregion
+//#region src/assets/diagnostics.d.ts
+declare const TOPIK_ASSET_DIAGNOSTIC_IDS: readonly ["TOPIK_ASSET_UNSUPPORTED_VERSION", "TOPIK_ASSET_DUPLICATE_MEMBER", "TOPIK_ASSET_SCHEMA_INVALID", "TOPIK_ASSET_NON_CANONICAL", "TOPIK_ASSET_NAME_INVALID", "TOPIK_ASSET_NAME_COLLISION", "TOPIK_ASSET_NAME_GENERATOR_REQUIRED", "TOPIK_ASSET_PROJECT_NAMESPACE_INVALID", "TOPIK_ASSET_PATH_INVALID", "TOPIK_ASSET_PATH_COLLISION", "TOPIK_ASSET_REFERENCE_AMBIGUOUS", "TOPIK_ASSET_REFERENCE_MALFORMED", "TOPIK_ASSET_REFERENCE_MISSING", "TOPIK_ASSET_FILE_MISSING", "TOPIK_ASSET_DIGEST_MISMATCH", "TOPIK_ASSET_SIZE_MISMATCH", "TOPIK_ASSET_MEDIA_TYPE_MISMATCH", "TOPIK_ASSET_FILE_TYPE_UNSUPPORTED", "TOPIK_ASSET_ACTIVE_CONTENT_UNSUPPORTED", "TOPIK_ASSET_REFERENCE_ACCESSIBILITY_INVALID", "TOPIK_EXTERNAL_REFERENCE_UNSAFE", "TOPIK_ASSET_INVENTORY_INCOMPLETE", "TOPIK_ASSET_VERSION_INCOMPARABLE"];
+declare const TOPIK_ASSET_DEFAULT_CORRELATION_ID: "cor_00000000000000000000000000";
+declare const TOPIK_ASSET_CORRELATION_ID_PATTERN: RegExp;
+type TopikAssetCorrelationId = `cor_${string}`;
+type TopikAssetDiagnosticId = (typeof TOPIK_ASSET_DIAGNOSTIC_IDS)[number];
+type TopikAssetPathDiagnosticReason = "invalid_utf8" | "capability_invalid" | "unicode_version_unsupported" | "not_nfc" | "absolute" | "separator_alias" | "dot_segment" | "percent_noncanonical" | "forbidden_character" | "reserved_name" | "too_long" | "casefold_collision";
+type TopikAssetRecoveryCategory = "upgrade-reader" | "repair-source" | "restore-file" | "verify-bytes" | "preserve-read-only";
+interface TopikAssetDiagnosticLocation {
+  jsonPointer?: string;
+  contentPosition?: string;
+  path?: string;
+  key?: string;
+  commit?: string;
+}
+interface TopikAssetDiagnostic {
+  id: TopikAssetDiagnosticId;
+  /** Safe opaque operation correlation; callers may replace the deterministic default. */
+  correlationId: TopikAssetCorrelationId;
+  severity: "error";
+  consequence: "block-resource" | "block-identity-and-writes" | "block-mutation";
+  descriptorVersion: string;
+  location: TopikAssetDiagnosticLocation;
+  recovery: TopikAssetRecoveryCategory;
+  reason?: TopikAssetPathDiagnosticReason;
+  /** Human wording is intentionally not a stable compatibility surface. */
+  message: string;
+}
+type TopikAssetResult<T> = {
+  ok: true;
+  value: T;
+  diagnostics: readonly [];
+  source?: Uint8Array;
+} | {
+  ok: false;
+  value?: T;
+  diagnostics: readonly TopikAssetDiagnostic[];
+  /** Exact caller bytes are non-loggable evidence; never copy them into diagnostics/telemetry. */
+  source?: Uint8Array;
+};
+declare function correlateTopikAssetResult<T>(result: TopikAssetResult<T>, correlationId: TopikAssetCorrelationId): TopikAssetResult<T>;
+//#endregion
+//#region src/assets/asset.d.ts
+interface ParsedAsset {
+  asset: Asset;
+  canonicalBytes: Uint8Array;
+}
+/** Compiler-generated name used by automatic Asset compilation. */
+type GeneratedAssetName = TopikGeneratedAssetName;
+declare const assetBlobUriBrand: unique symbol;
+/** Opaque compiler output path for one SHA-256-addressed Asset blob. */
+type AssetBlobUri = string & {
+  readonly [assetBlobUriBrand]: "AssetBlobUri";
+};
+declare function isAssetBlobUri(value: unknown): value is AssetBlobUri;
+declare function parseAssetBlobUri(value: string): AssetBlobUri;
+declare function parseGeneratedAssetName(value: string): GeneratedAssetName;
+/** Asset descriptor emitted by the compiler with a materialized payload. */
+interface CompiledAsset extends Asset {
+  name: GeneratedAssetName;
+  spec: {
+    uri: AssetBlobUri;
+    integrity: `sha256:${string}`;
+    size: number;
+    mediaType: string;
+  };
+}
+declare function parseAsset(input: string | Uint8Array): TopikAssetResult<ParsedAsset>;
+declare function validateAssetValue(value: unknown): TopikAssetResult<Asset>;
+/** Serialize one Asset to deterministic UTF-8 canonical JSON and prove its round trip. */
+declare function serializeAsset(value: unknown): TopikAssetResult<Uint8Array>;
+/** Admit a compiler-materialized blob path; Asset resources may use other URI forms. */
+declare function validateAssetBlobUri(value: string): TopikAssetResult<{
+  uri: AssetBlobUri;
+}>;
+declare function isGeneratedAssetName(value: unknown): value is GeneratedAssetName;
+declare function validateProjectNamespace(value: string): TopikAssetResult<string>;
+interface GenerateAutomaticAssetNameOptions {
+  projectNamespace: string;
+  manifestRelativePath: string;
+}
+declare function generateAutomaticAssetName(options: GenerateAutomaticAssetNameOptions): TopikAssetResult<GeneratedAssetName>;
+declare function topikAssetNameDescriptor(): {
+  id: typeof TOPIK_ASSET_NAME_VERSION;
+};
+//#endregion
+//#region src/assets/identity.d.ts
+interface TopikAssetReferenceMappingV1 {
+  resource: string;
+  position: string;
+  slot: string;
+  name: string;
+}
+interface TopikAssetSemanticRecordV1 {
+  descriptor: "topik-asset-semantic-v1";
+  assetNames: readonly string[];
+  references: readonly TopikAssetReferenceMappingV1[];
+}
+interface TopikMaterializationResourceV1 {
+  resource: string;
+  path: string;
+  size: number;
+  sha256: string;
+}
+interface TopikMaterializationPayloadV1 {
+  path: string;
+  size: number;
+  sha256: string;
+  assetNames: readonly string[];
+}
+interface TopikMaterializationRecordV1 {
+  descriptor: "topik-materialization-v1";
+  resources: readonly TopikMaterializationResourceV1[];
+  payloads: readonly TopikMaterializationPayloadV1[];
+}
+interface TopikMaterializationResourceInput {
+  resource: {
+    type: string;
+    name: string;
+  };
+  bytes: Uint8Array;
+}
+interface TopikMaterializationPayloadInput {
+  path: string;
+  bytes: Uint8Array;
+  assetNames: readonly string[];
+}
+declare function createTopikAssetSemanticRecord(assets: readonly Asset[], references: readonly TopikAssetReferenceMappingV1[]): TopikAssetSemanticRecordV1;
+declare function createTopikMaterializationRecord(resources: readonly TopikMaterializationResourceInput[], payloads: readonly TopikMaterializationPayloadInput[]): TopikMaterializationRecordV1;
+declare function validateTopikMaterializationRecord(record: unknown, resources: readonly Resource[], semantic: unknown): TopikAssetResult<TopikMaterializationRecordV1>;
+declare function digestTopikAssetSemanticRecord(record: TopikAssetSemanticRecordV1): string;
+declare function digestTopikMaterializationRecord(record: TopikMaterializationRecordV1): string;
+declare function compareTopikAssetIdentities(left: {
+  semantic: TopikAssetSemanticRecordV1;
+  materialization: TopikMaterializationRecordV1;
+}, right: {
+  semantic: TopikAssetSemanticRecordV1;
+  materialization: TopikMaterializationRecordV1;
+}): TopikAssetResult<{
+  semanticEqual: boolean;
+  exactEqual: boolean;
+}>;
+//#endregion
+//#region src/compile/assets.d.ts
+type ContentBearingResource = CoursePage | Guide | WikiPage;
+interface AssetNameInput {
+  /** Absolute native path after resolving the authored reference within its allowed root.
+   * This is a file location, not a portable identity or a delivery URL. */
+  resolvedAssetPath: string;
+}
+/** Return a stable, canonical auto-v1 name. Called once per distinct asset path per compilation. */
+type AssetNameGenerator = (input: AssetNameInput) => string | Promise<string>;
+interface AssetCompilationOptions {
+  /** Required only when supported local references are discovered automatically. */
+  generateName?: AssetNameGenerator;
+}
+interface CompileAssetResourcesInput extends AssetCompilationOptions {
+  rootDir: string;
+  resources: readonly SourceResource[];
+  /** Compilation-root-relative source paths keyed by `Type/name`. */
+  sourcePathsByResource: Readonly<Record<string, string>>;
+  /** Optional per-document containment directories relative to rootDir (empty for root).
+   * Asset identities still use paths relative to rootDir. */
+  sourceDirectoriesByResource?: Readonly<Record<string, string>>;
+  /** Other consumed compiler inputs that cannot be owned as Asset bytes. */
+  protectedSourcePaths?: readonly string[];
+}
+interface AssetPayload {
+  path: AssetBlobUri;
+  integrity: `sha256:${string}`;
+  mediaType: string;
+  size: number;
+  bytes: Uint8Array;
+  assetNames: readonly string[];
+}
+interface AssetCompilationResult {
+  resources: CompiledResource[];
+  payloads: AssetPayload[];
+  semantic: TopikAssetSemanticRecordV1;
+  materialization: TopikMaterializationRecordV1;
+}
+type CompiledResource = SourceResource | CompiledAsset;
+declare class AssetCompilationError extends Error {
+  readonly diagnostics: readonly TopikAssetDiagnostic[];
+  constructor(message: string, diagnostics?: readonly TopikAssetDiagnostic[]);
+}
+/** Discover and resolve one compilation-wide Asset set and deduplicated payload inventory. */
+declare function compileAssetResources(input: CompileAssetResourcesInput): Promise<AssetCompilationResult>;
+//#endregion
+//#region src/preview.d.ts
+/** Browser-safe capability and wire types. No filesystem imports at runtime. */
+declare const TOPIK_PREVIEW_PROTOCOL: "topik-preview/1";
+interface CourseNavigationModule {
+  name: string;
+  declarationIndex: number;
+  pages: {
+    name: string;
+    declarationIndex: number;
+  }[];
+}
+type CourseNavigationIndex = Record<string, {
+  modules: CourseNavigationModule[];
+}>;
+type PreviewPayloadDescriptor = Omit<AssetPayload, "bytes">;
+interface PreviewDiagnostic {
+  id: string;
+  message: string;
+}
+interface PreviewState {
+  protocol: typeof TOPIK_PREVIEW_PROTOCOL;
+  sessionId: string;
+  sequence: number;
+  /** Last successful generation, retained during compiling/error; null before first success. */
+  generation: number | null;
+  status: "compiling" | "ready" | "error";
+  diagnostics: PreviewDiagnostic[];
+  resources: Resource[];
+  payloads: PreviewPayloadDescriptor[];
+  courseNavigation: CourseNavigationIndex;
+}
+//#endregion
+export { TopikAssetPathDiagnosticReason as $, AssetBlobUri as A, parseGeneratedAssetName as B, TopikMaterializationResourceV1 as C, digestTopikAssetSemanticRecord as D, createTopikMaterializationRecord as E, generateAutomaticAssetName as F, validateProjectNamespace as G, topikAssetNameDescriptor as H, isAssetBlobUri as I, TOPIK_ASSET_DIAGNOSTIC_IDS as J, TOPIK_ASSET_CORRELATION_ID_PATTERN as K, isGeneratedAssetName as L, GenerateAutomaticAssetNameOptions as M, GeneratedAssetName as N, digestTopikMaterializationRecord as O, ParsedAsset as P, TopikAssetDiagnosticLocation as Q, parseAsset as R, TopikMaterializationResourceInput as S, createTopikAssetSemanticRecord as T, validateAssetBlobUri as U, serializeAsset as V, validateAssetValue as W, TopikAssetDiagnostic as X, TopikAssetCorrelationId as Y, TopikAssetDiagnosticId as Z, TopikAssetReferenceMappingV1 as _, PreviewState as a, ASSET_TYPE as at, TopikMaterializationPayloadV1 as b, AssetCompilationOptions as c, TOPIK_ASSET_REFERENCE_VERSION as ct, AssetNameInput as d, TOPIK_MATERIALIZATION_VERSION as dt, TopikAssetRecoveryCategory as et, AssetPayload as f, TOPIK_PATH_V1_DESCRIPTOR as ft, compileAssetResources as g, SourceResource as gt, ContentBearingResource as h, ResourceType as ht, PreviewPayloadDescriptor as i, ASSET_SCHEMA_ID as it, CompiledAsset as j, validateTopikMaterializationRecord as k, AssetCompilationResult as l, TOPIK_BLOB_OUTPUT_PREFIX as lt, CompiledResource as m, Resource as mt, CourseNavigationModule as n, correlateTopikAssetResult as nt, TOPIK_PREVIEW_PROTOCOL as o, TOPIK_ASSET_LIMITS as ot, CompileAssetResourcesInput as p, TOPIK_PATH_VERSION as pt, TOPIK_ASSET_DEFAULT_CORRELATION_ID as q, PreviewDiagnostic as r, ASSET_API_VERSION as rt, AssetCompilationError as s, TOPIK_ASSET_NAME_VERSION as st, CourseNavigationIndex as t, TopikAssetResult as tt, AssetNameGenerator as u, TOPIK_JSON_VERSION as ut, TopikAssetSemanticRecordV1 as v, compareTopikAssetIdentities as w, TopikMaterializationRecordV1 as x, TopikMaterializationPayloadInput as y, parseAssetBlobUri as z };

package/dist/preview.d.mts

@@ -0,0 +1,2 @@
+import { a as PreviewState, i as PreviewPayloadDescriptor, n as CourseNavigationModule, o as TOPIK_PREVIEW_PROTOCOL, r as PreviewDiagnostic, t as CourseNavigationIndex } from "./preview-C_3OnNUi.mjs";
+export { CourseNavigationIndex, CourseNavigationModule, PreviewDiagnostic, PreviewPayloadDescriptor, PreviewState, TOPIK_PREVIEW_PROTOCOL };

package/dist/preview.mjs

@@ -0,0 +1,5 @@
+//#region src/preview.ts
+/** Browser-safe capability and wire types. No filesystem imports at runtime. */
+const TOPIK_PREVIEW_PROTOCOL = "topik-preview/1";
+//#endregion
+export { TOPIK_PREVIEW_PROTOCOL };

package/dist/wiki-navigation.d.mts

@@ -0,0 +1,65 @@
+import { WikiDropdownNavNode, WikiExternalDropdownNavNode, WikiExternalTabNavNode, WikiInternalDropdownNavNode, WikiInternalTabNavNode, WikiNavContainerNode, WikiNavNode, WikiNavigation, WikiPageNavNode, WikiTabNavNode } from "@topik/schema/wiki/v1";
+//#region src/wiki-navigation.d.ts
+export type ResolvedWikiPage = {
+  /** The compiled WikiPage resource name. */
+  page: string;
+  /** The page navigation node from the Wiki resource. */
+  node: WikiPageNavNode;
+  /** Public path without a leading slash. */
+  route: string;
+  /** Logical Markdown source path without an extension. */
+  sourcePath: string;
+  /** Internal navigation containers from outermost to innermost. */
+  ancestors: readonly WikiNavContainerNode[];
+};
+export type ResolvedWikiNavigation = {
+  pages: readonly ResolvedWikiPage[];
+  pageByName: ReadonlyMap<string, ResolvedWikiPage>;
+  pageByRoute: ReadonlyMap<string, ResolvedWikiPage>;
+  pageBySourcePath: ReadonlyMap<string, ResolvedWikiPage>;
+  sourceVersion?: 1;
+};
+export type ResolvedWikiContentLink = {
+  page: ResolvedWikiPage;
+  route: string;
+  hash: string;
+  search: string;
+};
+export type ResolvedWikiContentReference = {
+  kind: "page";
+  target: ResolvedWikiContentLink;
+} | {
+  kind: "asset";
+} | {
+  kind: "external";
+} | {
+  kind: "unresolved";
+};
+/** Classify an already-admitted compiled href without treating missing page context as external.
+ * Local files/downloads must first be compiled to Asset references using their source inventory;
+ * this browser-safe helper never guesses whether an unresolved local path names a file.
+ */
+export declare function resolveWikiContentReference(href: string, currentPageName: string, resolved: ResolvedWikiNavigation): ResolvedWikiContentReference;
+/** Returns true for tab, dropdown, and group nodes containing navigation children. */
+export declare function hasWikiNavChildren(node: WikiNavNode): node is WikiNavContainerNode;
+export declare function isInternalWikiTab(node: WikiNavNode): node is WikiInternalTabNavNode;
+export declare function isExternalWikiTab(node: WikiNavNode): node is WikiExternalTabNavNode;
+export declare function isInternalWikiDropdown(node: WikiNavNode): node is WikiInternalDropdownNavNode;
+export declare function isExternalWikiDropdown(node: WikiNavNode): node is WikiExternalDropdownNavNode;
+/** Resolves page routes, source paths, and navigation ancestry from a compiled Wiki tree. */
+export declare function resolveWikiNavigation(navigation: WikiNavigation | readonly WikiNavNode[], options?: {
+  sourceVersion?: 1;
+}): ResolvedWikiNavigation;
+/** Finds the first page node in navigation order, ignoring external destinations. */
+export declare function findFirstWikiPage(navigation: WikiNavigation | readonly WikiNavNode[]): WikiPageNavNode | null;
+/** Returns the internal containers owning a page, or an empty array for an unknown page. */
+export declare function findWikiPageAncestors(resolved: ResolvedWikiNavigation, pageName: string): readonly WikiNavContainerNode[];
+/** Resolves compiled WikiPage references by name, or legacy links against their source context. */
+export declare function resolveWikiContentHref(href: string, currentPageName: string, resolved: ResolvedWikiNavigation): ResolvedWikiContentLink | null;
+export declare function joinWikiPath(prefix: string, slug?: string): string;
+export type InternalWikiTab = WikiInternalTabNavNode;
+export type ExternalWikiTab = WikiExternalTabNavNode;
+export type InternalWikiDropdown = WikiInternalDropdownNavNode;
+export type ExternalWikiDropdown = WikiExternalDropdownNavNode;
+export type WikiSwitcherNode = WikiTabNavNode | WikiDropdownNavNode;
+//#endregion

package/dist/wiki-navigation.mjs

@@ -0,0 +1,133 @@
+import { a as resolveDeclaredSourcePage, i as resolveDeclaredPublicRoute, n as hasDeclaredFolder, o as resolveNavigationPath, r as isFolderHref } from "./folder-links-DI4xfipU.mjs";
+import { parseTopikResourceReference } from "@topik/content";
+//#region src/wiki-navigation.ts
+const INTERNAL_WIKI_ORIGIN = "https://topik.invalid";
+/** Classify an already-admitted compiled href without treating missing page context as external.
+* Local files/downloads must first be compiled to Asset references using their source inventory;
+* this browser-safe helper never guesses whether an unresolved local path names a file.
+*/
+function resolveWikiContentReference(href, currentPageName, resolved) {
+	if (/^asset:/i.test(href)) return { kind: "asset" };
+	if (/^(?:https?|mailto|tel):/i.test(href)) return { kind: "external" };
+	const target = resolveWikiContentHref(href, currentPageName, resolved);
+	return target ? {
+		kind: "page",
+		target
+	} : { kind: "unresolved" };
+}
+/** Returns true for tab, dropdown, and group nodes containing navigation children. */
+function hasWikiNavChildren(node) {
+	return "children" in node;
+}
+function isInternalWikiTab(node) {
+	return node.type === "tab" && "children" in node;
+}
+function isExternalWikiTab(node) {
+	return node.type === "tab" && "href" in node;
+}
+function isInternalWikiDropdown(node) {
+	return node.type === "dropdown" && "children" in node;
+}
+function isExternalWikiDropdown(node) {
+	return node.type === "dropdown" && "href" in node;
+}
+/** Resolves page routes, source paths, and navigation ancestry from a compiled Wiki tree. */
+function resolveWikiNavigation(navigation, options = {}) {
+	const pages = [];
+	const pageByName = /* @__PURE__ */ new Map();
+	const pageByRoute = /* @__PURE__ */ new Map();
+	const pageBySourcePath = /* @__PURE__ */ new Map();
+	const visit = (nodes, prefix, ancestors) => {
+		for (const node of nodes) if (node.type === "page") {
+			const route = joinWikiPath(prefix, node.slug);
+			const resolved = {
+				page: node.page,
+				node,
+				route,
+				sourcePath: node.sourcePath ?? joinWikiPath(prefix, node.slug || "index"),
+				ancestors
+			};
+			if (pageByName.has(node.page)) throw new Error(`Wiki navigation contains page ${node.page} more than once`);
+			if (pageByRoute.has(route)) throw new Error(`Wiki navigation contains duplicate route /${route}`);
+			if (pageBySourcePath.has(resolved.sourcePath)) throw new Error("Wiki navigation contains duplicate source paths");
+			pages.push(resolved);
+			pageByName.set(node.page, resolved);
+			pageByRoute.set(route, resolved);
+			pageBySourcePath.set(resolved.sourcePath, resolved);
+		} else if (hasWikiNavChildren(node)) visit(node.children, joinWikiPath(prefix, node.slug), [...ancestors, node]);
+	};
+	visit(navigation, "", []);
+	return {
+		pages,
+		pageByName,
+		pageByRoute,
+		pageBySourcePath,
+		...options.sourceVersion !== void 0 ? { sourceVersion: options.sourceVersion } : {}
+	};
+}
+/** Finds the first page node in navigation order, ignoring external destinations. */
+function findFirstWikiPage(navigation) {
+	for (const node of navigation) {
+		if (node.type === "page") return node;
+		if (hasWikiNavChildren(node)) {
+			const page = findFirstWikiPage(node.children);
+			if (page) return page;
+		}
+	}
+	return null;
+}
+/** Returns the internal containers owning a page, or an empty array for an unknown page. */
+function findWikiPageAncestors(resolved, pageName) {
+	return resolved.pageByName.get(pageName)?.ancestors ?? [];
+}
+/** Resolves compiled WikiPage references by name, or legacy links against their source context. */
+function resolveWikiContentHref(href, currentPageName, resolved) {
+	if (href.startsWith("asset:")) return null;
+	const reference = parseTopikResourceReference(href);
+	if (reference) {
+		if (reference.type !== "WikiPage") return null;
+		const page = resolved.pageByName.get(reference.name);
+		return page ? {
+			page,
+			route: page.route,
+			hash: reference.hash,
+			search: reference.search
+		} : null;
+	}
+	const currentPage = resolved.pageByName.get(currentPageName);
+	if (!currentPage) return null;
+	if (href.startsWith("#")) return {
+		page: currentPage,
+		route: currentPage.route,
+		hash: href.slice(1),
+		search: ""
+	};
+	let url;
+	try {
+		const sourcePath = currentPage.sourcePath.split("/").map(encodeURIComponent).join("/");
+		url = new URL(href, `${INTERNAL_WIKI_ORIGIN}/${sourcePath}`);
+	} catch {
+		return null;
+	}
+	if (url.origin !== INTERNAL_WIKI_ORIGIN) return null;
+	const pathname = resolveNavigationPath(href, currentPage.sourcePath);
+	if (pathname === void 0) return null;
+	const markdown = /\.(?:mdx?|markdown)$/i.test(pathname) && !hasDeclaredFolder(pathname, resolved.pageBySourcePath);
+	const normalizedPath = markdown ? pathname.replace(/\.(?:mdx?|markdown)$/i, "") : pathname;
+	const route = normalizedPath === "index" ? "" : normalizedPath.replace(/\/index$/, "");
+	const folder = isFolderHref(href);
+	const sourceLink = !href.startsWith("/") || markdown || folder;
+	const page = sourceLink && (resolved.sourceVersion === 1 || folder || hasDeclaredFolder(normalizedPath, resolved.pageBySourcePath)) ? markdown ? resolved.pageBySourcePath.get(normalizedPath) : resolveDeclaredSourcePage(normalizedPath, resolved.pageBySourcePath, folder) : (!sourceLink && href.startsWith("/") ? resolveDeclaredPublicRoute(href, resolved.pageByRoute, true) : resolved.pageByRoute.get(route)) ?? resolveDeclaredSourcePage(normalizedPath, resolved.pageBySourcePath, true);
+	return page ? {
+		page,
+		route: page.route,
+		hash: url.hash.replace(/^#/, ""),
+		search: url.search
+	} : null;
+}
+function joinWikiPath(prefix, slug) {
+	if (!slug) return prefix;
+	return prefix ? `${prefix}/${slug}` : slug;
+}
+//#endregion
+export { findFirstWikiPage, findWikiPageAncestors, hasWikiNavChildren, isExternalWikiDropdown, isExternalWikiTab, isInternalWikiDropdown, isInternalWikiTab, joinWikiPath, resolveWikiContentHref, resolveWikiContentReference, resolveWikiNavigation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topik/core",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.6",
   "description": "Topik core library",
   "license": "MIT",
   "repository": {
@@ -14,6 +14,9 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./course-navigation": "./dist/course-navigation.mjs",
+    "./preview": "./dist/preview.mjs",
+    "./wiki-navigation": "./dist/wiki-navigation.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -23,16 +26,16 @@
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "chokidar": "^5.0.0",
-    "yaml": "^2.9.0",
-    "zod": "^4.4.3",
-    "@topik/content-schema": "0.1.0-alpha.4",
-    "@topik/schema": "0.1.0-alpha.4"
+    "yaml": "^2.9.1",
+    "zod": "^4.6.7",
+    "@topik/content": "0.1.0-alpha.6",
+    "@topik/schema": "0.1.0-alpha.6"
   },
   "devDependencies": {
-    "@types/node": "22.20.1",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "typescript": "^6.0.3",
-    "vite-plus": "0.2.4"
+    "@types/node": "22.20.4",
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0"
   },
   "scripts": {
     "build": "vp pack",