cluaupp 1.4.1 → 1.5.1

package/src/target/context-check.ts

@@ -0,0 +1,177 @@
+/**
+ * Scan CL++ source for Context Safety violations (capability rules).
+ * Heuristic line scan — not a full AST. Good enough for phase-1 platform rules.
+ */
+
+import type { CompileDiagnostic } from "../clpp/contract.js";
+import { builtinCapabilityProfile, type CapabilityProfile, type CapabilityRule } from "./capabilities.js";
+import { runContextFromFileName, type RunContext } from "./roblox.js";
+
+export interface ContextViolation extends CompileDiagnostic {
+	code: string;
+	context: RunContext;
+}
+
+/** Strip line comments, block comments, and rough string/char literals for scanning. */
+export function stripNoise(source: string): string {
+	let out = "";
+	let i = 0;
+	while (i < source.length) {
+		const c = source[i];
+		const next = source[i + 1];
+		if (c === "/" && next === "/") {
+			while (i < source.length && source[i] !== "\n") {
+				i++;
+			}
+			continue;
+		}
+		if (c === "/" && next === "*") {
+			i += 2;
+			while (i < source.length - 1 && !(source[i] === "*" && source[i + 1] === "/")) {
+				if (source[i] === "\n") {
+					out += "\n";
+				}
+				i++;
+			}
+			i += 2;
+			continue;
+		}
+		if (c === '"' || c === "'" || c === "`") {
+			const quote = c;
+			out += " ";
+			i++;
+			while (i < source.length && source[i] !== quote) {
+				if (source[i] === "\\" && i + 1 < source.length) {
+					i += 2;
+					continue;
+				}
+				if (source[i] === "\n") {
+					out += "\n";
+				}
+				i++;
+			}
+			i++;
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return out;
+}
+
+function lineColumn(source: string, index: number): { line: number; column: number } {
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < index && i < source.length; i++) {
+		if (source[i] === "\n") {
+			line++;
+			column = 1;
+		} else {
+			column++;
+		}
+	}
+	return { line, column };
+}
+
+function activeRegionContext(lineText: string, current: RunContext, fileContext: RunContext): RunContext {
+	const trimmed = lineText.trim();
+	if (/^\[\[\s*server\s*\]\]/i.test(trimmed)) {
+		return "Server";
+	}
+	if (/^\[\[\s*client\s*\]\]/i.test(trimmed)) {
+		return "Client";
+	}
+	if (/^\[\[\s*shared\s*\]\]/i.test(trimmed) || /^\[\[\s*plugin\s*\]\]/i.test(trimmed)) {
+		if (/plugin/i.test(trimmed)) {
+			return "Plugin";
+		}
+		return "Shared";
+	}
+	return current || fileContext;
+}
+
+export function checkContextSafety(
+	source: string,
+	fileName: string,
+	profile: CapabilityProfile = builtinCapabilityProfile(),
+): ContextViolation[] {
+	const fileContext = runContextFromFileName(fileName);
+	const cleaned = stripNoise(source);
+	const violations: ContextViolation[] = [];
+	const lines = cleaned.split(/\r?\n/);
+	let region: RunContext = fileContext;
+
+	const compiled = profile.rules.map((rule) => ({
+		rule,
+		re: new RegExp(rule.pattern, "g"),
+	}));
+
+	let offset = 0;
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+		const lineText = lines[lineIndex];
+		region = activeRegionContext(lineText, region, fileContext);
+
+		for (const { rule, re } of compiled) {
+			if (!rule.forbiddenIn.includes(region)) {
+				continue;
+			}
+			re.lastIndex = 0;
+			let match: RegExpExecArray | null;
+			while ((match = re.exec(lineText))) {
+				const abs = offset + (match.index || 0);
+				const pos = lineColumn(source, mapCleanIndexToSource(source, cleaned, abs));
+				violations.push({
+					code: rule.id,
+					message: `${rule.id}: ${rule.message} (context=${region})`,
+					line: pos.line,
+					column: pos.column,
+					severity: rule.severity,
+					context: region,
+				});
+			}
+		}
+		offset += lineText.length + 1;
+	}
+
+	return violations;
+}
+
+/** Best-effort map from cleaned index back toward original (same newlines preserved). */
+function mapCleanIndexToSource(original: string, cleaned: string, cleanIndex: number): number {
+	if (cleaned.length === original.length) {
+		return Math.min(cleanIndex, original.length);
+	}
+	// Newlines aligned — walk both counting newlines + approx columns
+	let oi = 0;
+	let ci = 0;
+	while (ci < cleanIndex && oi < original.length && ci < cleaned.length) {
+		if (original[oi] === cleaned[ci]) {
+			oi++;
+			ci++;
+			continue;
+		}
+		// skip noise already stripped from cleaned
+		oi++;
+	}
+	return oi;
+}
+
+export function formatContextViolations(fileName: string, violations: ContextViolation[]): string {
+	return violations
+		.map((v) => `${fileName}:${v.line}:${v.column}: ${v.severity}[${v.code}]: ${v.message}`)
+		.join("\n");
+}
+
+export function assertContextSafe(source: string, fileName: string, profile?: CapabilityProfile): void {
+	const all = checkContextSafety(source, fileName, profile);
+	const errors = all.filter((v) => v.severity === "error");
+	if (errors.length) {
+		throw new Error(formatContextViolations(fileName, errors));
+	}
+}
+
+export function listContextWarnings(source: string, fileName: string, profile?: CapabilityProfile): ContextViolation[] {
+	return checkContextSafety(source, fileName, profile).filter((v) => v.severity === "warning");
+}
+
+export type { CapabilityRule };

package/src/target/datamodel-check.ts

@@ -0,0 +1,188 @@
+/**
+ * Scan CL++ for WaitForChild / FindFirstChild chains against the Typed DataModel graph.
+ * Supports GetService roots and simple `auto x = …WaitForChild` variable binding.
+ */
+
+import type { CompileDiagnostic } from "../clpp/contract.js";
+import type { DatamodelNode, DatamodelProfile } from "./datamodel.js";
+import { lookupChild } from "./datamodel.js";
+
+export interface DatamodelViolation extends CompileDiagnostic {
+	code: string;
+	pathHint?: string;
+}
+
+export function stripComments(source: string): string {
+	let out = "";
+	let i = 0;
+	while (i < source.length) {
+		const c = source[i];
+		const next = source[i + 1];
+		if (c === "/" && next === "/") {
+			while (i < source.length && source[i] !== "\n") i++;
+			continue;
+		}
+		if (c === "/" && next === "*") {
+			i += 2;
+			while (i < source.length - 1 && !(source[i] === "*" && source[i + 1] === "/")) {
+				if (source[i] === "\n") out += "\n";
+				i++;
+			}
+			i += 2;
+			continue;
+		}
+		if (c === '"' || c === "'" || c === "`") {
+			const quote = c;
+			out += c;
+			i++;
+			while (i < source.length && source[i] !== quote) {
+				if (source[i] === "\\" && i + 1 < source.length) {
+					out += source[i] + source[i + 1];
+					i += 2;
+					continue;
+				}
+				out += source[i];
+				i++;
+			}
+			if (i < source.length) {
+				out += source[i];
+				i++;
+			}
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return out;
+}
+
+const CHAIN =
+	/(?:GetService\s*<\s*([A-Za-z_]\w*)\s*>\s*\(\s*\)|GetService\s*\(\s*"([A-Za-z_]\w*)"\s*\)|(?:\bgame\s*\.\s*)?([A-Za-z_]\w*))((?:\s*\.\s*(?:WaitForChild|FindFirstChild|FindFirstChildOfClass|FindFirstChildWhichIsA)\s*\(\s*"[^"]+"\s*(?:,[^)]*)?\))+)/g;
+
+const CHILD_NAME = /\.\s*(?:WaitForChild|FindFirstChild|FindFirstChildOfClass|FindFirstChildWhichIsA)\s*\(\s*"([^"]+)"/g;
+
+const BIND =
+	/(?:auto|Instance|[A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*=\s*(?:GetService\s*<\s*([A-Za-z_]\w*)\s*>\s*\(\s*\)|GetService\s*\(\s*"([A-Za-z_]\w*)"\s*\)|([A-Za-z_]\w*))((?:\s*\.\s*(?:WaitForChild|FindFirstChild|FindFirstChildOfClass|FindFirstChildWhichIsA)\s*\(\s*"[^"]+"\s*(?:,[^)]*)?\))*)/g;
+
+function lineCol(source: string, index: number): { line: number; column: number } {
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < index && i < source.length; i++) {
+		if (source[i] === "\n") {
+			line++;
+			column = 1;
+		} else {
+			column++;
+		}
+	}
+	return { line, column };
+}
+
+function serviceRoot(profile: DatamodelProfile, serviceName: string): DatamodelNode | null {
+	return lookupChild(profile.root, serviceName) || null;
+}
+
+function extractChildNames(chainTail: string): string[] {
+	const names: string[] = [];
+	CHILD_NAME.lastIndex = 0;
+	let m: RegExpExecArray | null;
+	while ((m = CHILD_NAME.exec(chainTail))) {
+		names.push(m[1]);
+	}
+	return names;
+}
+
+function walkFrom(profile: DatamodelProfile, rootName: string, names: string[]): { node: DatamodelNode; walked: string; missing?: string } | null {
+	let node = serviceRoot(profile, rootName) || profile.byPath[rootName] || null;
+	if (!node) return null;
+	let walked = rootName;
+	for (const childName of names) {
+		const child = lookupChild(node, childName);
+		if (!child) {
+			return { node, walked, missing: childName };
+		}
+		node = child;
+		walked = `${walked}.${childName}`;
+	}
+	return { node, walked };
+}
+
+function buildVarEnv(clean: string, profile: DatamodelProfile): Map<string, DatamodelNode> {
+	const env = new Map<string, DatamodelNode>();
+	BIND.lastIndex = 0;
+	let m: RegExpExecArray | null;
+	while ((m = BIND.exec(clean))) {
+		const varName = m[1];
+		const rootName = m[2] || m[3] || m[4];
+		const chainTail = m[5] || "";
+		if (!rootName) continue;
+		const names = extractChildNames(chainTail);
+		const walked = walkFrom(profile, rootName, names);
+		if (walked && !walked.missing) {
+			env.set(varName, walked.node);
+		}
+	}
+	return env;
+}
+
+function validateChain(
+	profile: DatamodelProfile,
+	rootName: string,
+	names: string[],
+	source: string,
+	index: number,
+	fileHint?: string,
+	env?: Map<string, DatamodelNode>,
+): DatamodelViolation[] {
+	const out: DatamodelViolation[] = [];
+	let node = serviceRoot(profile, rootName) || profile.byPath[rootName] || env?.get(rootName) || null;
+	if (!node) {
+		return out;
+	}
+	let walked = node.path;
+	for (const childName of names) {
+		const child = lookupChild(node, childName);
+		if (!child) {
+			const { line, column } = lineCol(source, index);
+			const known = Object.keys(node.children).slice(0, 12).join(", ") || "(none)";
+			out.push({
+				code: "CLUAU_DM_MISSING_CHILD",
+				message: `Typed DataModel: "${childName}" is not a child of ${walked} (${node.className}). Known: ${known}`,
+				line,
+				column,
+				severity: "error",
+				pathHint: `${node.path}.${childName}`,
+			});
+			void fileHint;
+			break;
+		}
+		node = child;
+		walked = node.path;
+	}
+	return out;
+}
+
+export function checkDatamodelPaths(source: string, profile: DatamodelProfile): DatamodelViolation[] {
+	const clean = stripComments(source);
+	const env = buildVarEnv(clean, profile);
+	const violations: DatamodelViolation[] = [];
+	CHAIN.lastIndex = 0;
+	let m: RegExpExecArray | null;
+	while ((m = CHAIN.exec(clean))) {
+		const rootName = m[1] || m[2] || m[3];
+		const names = extractChildNames(m[4]);
+		if (!rootName || !names.length) continue;
+		violations.push(...validateChain(profile, rootName, names, source, m.index, undefined, env));
+	}
+	return violations;
+}
+
+export function assertDatamodelSafe(source: string, profile: DatamodelProfile): void {
+	const errors = checkDatamodelPaths(source, profile).filter((v) => v.severity === "error");
+	if (!errors.length) return;
+	throw new Error(`Typed DataModel:\n${errors.map((e) => `  ${e.line}:${e.column} ${e.code} ${e.message}`).join("\n")}`);
+}
+
+export function formatDatamodelViolations(file: string, violations: DatamodelViolation[]): string {
+	return violations.map((v) => `${file}:${v.line}:${v.column}: ${v.severity}: ${v.code} ${v.message}`).join("\n");
+}

package/src/target/datamodel-generate.ts

@@ -0,0 +1,78 @@
+/**
+ * Emit Typed DataModel profile JSON + CL++ IntelliSense header.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import type { DatamodelNode, DatamodelProfile } from "./datamodel.js";
+import { buildDatamodelProfile } from "./datamodel.js";
+
+function safeIdent(name: string): string {
+	const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
+	return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
+}
+
+function emitStruct(node: DatamodelNode, structName: string, depth: number): string {
+	const pad = "\t".repeat(depth);
+	const childEntries = Object.values(node.children);
+	if (!childEntries.length) {
+		return `${pad}// ${node.path} : ${node.className}\n`;
+	}
+	const lines: string[] = [];
+	lines.push(`${pad}struct ${structName} {`);
+	for (const child of childEntries.sort((a, b) => a.name.localeCompare(b.name))) {
+		const field = safeIdent(child.name);
+		const nested = `${structName}_${field}`;
+		if (Object.keys(child.children).length) {
+			lines.push(emitStruct(child, nested, depth + 1).trimEnd());
+			lines.push(`${pad}\t${nested} ${field}; // ${child.className}`);
+		} else {
+			lines.push(`${pad}\t${child.className} ${field};`);
+		}
+	}
+	lines.push(`${pad}};`);
+	return lines.join("\n") + "\n";
+}
+
+export function generateDatamodelHeader(profile: DatamodelProfile): string {
+	const body = emitStruct(profile.root, "Dm_DataModel", 0);
+	return [
+		"#pragma once",
+		"// Generated by Cluaupp Typed DataModel — do not edit.",
+		`// Project: ${profile.projectName} (${profile.projectJson})`,
+		`// schemaVersion: ${profile.schemaVersion}`,
+		"// IntelliSense / static check aid. Runtime remains Roblox FindFirstChild / WaitForChild.",
+		"",
+		body,
+		"// Root mirror (optional binding for IntelliSense only):",
+		"struct Dm_DataModel Dm;",
+		"",
+	].join("\n");
+}
+
+export function profileWithoutIndex(profile: DatamodelProfile): Omit<DatamodelProfile, "byPath"> & { paths: string[] } {
+	const { byPath, ...rest } = profile;
+	return { ...rest, paths: Object.keys(byPath).filter((p) => p !== "DataModel").sort() };
+}
+
+export function writeDatamodelArtifacts(
+	projectRoot: string,
+	opts?: { projectJson?: string; outDir?: string; headerPath?: string },
+): { profile: DatamodelProfile; profilePath: string; headerPath: string } | null {
+	const profile = buildDatamodelProfile(projectRoot, opts?.projectJson);
+	if (!profile) {
+		return null;
+	}
+	const outDir = opts?.outDir || path.join(projectRoot, ".cluaupp");
+	fs.mkdirSync(outDir, { recursive: true });
+	const profilePath = path.join(outDir, "datamodel-profile.json");
+	fs.writeFileSync(profilePath, JSON.stringify(profileWithoutIndex(profile), null, "\t") + "\n", "utf8");
+
+	const headerPath =
+		opts?.headerPath ||
+		path.join(projectRoot, "include", "clpp", "generated", "datamodel.clh");
+	fs.mkdirSync(path.dirname(headerPath), { recursive: true });
+	fs.writeFileSync(headerPath, generateDatamodelHeader(profile), "utf8");
+
+	return { profile, profilePath, headerPath };
+}

package/src/target/datamodel.ts

@@ -0,0 +1,261 @@
+/**
+ * Typed DataModel v1 — Rojo default.project.json → instance graph.
+ * Used for path validation at compile time and generated IntelliSense headers.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "comment-json";
+
+export const DATAMODEL_SCHEMA_VERSION = 1;
+
+export interface DatamodelNode {
+	/** Roblox instance name (tree key). */
+	name: string;
+	/** Dot path from game, e.g. ReplicatedStorage.Shared (DataModel root is "DataModel"). */
+	path: string;
+	className: string;
+	/** Project-relative fs path when backed by $path. */
+	fsPath?: string;
+	children: Record<string, DatamodelNode>;
+}
+
+export interface DatamodelProfile {
+	schemaVersion: number;
+	projectName: string;
+	projectJson: string;
+	root: DatamodelNode;
+	/** Flat index path → node */
+	byPath: Record<string, DatamodelNode>;
+	generatedAt: string;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return null;
+	}
+	return value as Record<string, unknown>;
+}
+
+function posix(p: string): string {
+	return p.replace(/\\/g, "/");
+}
+
+function childPath(parentPath: string, name: string): string {
+	if (!parentPath || parentPath === "DataModel") {
+		return name;
+	}
+	return `${parentPath}.${name}`;
+}
+
+function readMetaClassName(dir: string): string | undefined {
+	for (const metaName of ["init.meta.json", "init.meta.jsonc"]) {
+		const file = path.join(dir, metaName);
+		if (!fs.existsSync(file)) {
+			continue;
+		}
+		try {
+			const meta = asRecord(parse(fs.readFileSync(file, "utf8")));
+			if (meta && typeof meta.className === "string") {
+				return meta.className;
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+	return undefined;
+}
+
+function classFromFileName(fileName: string): { name: string; className: string } | null {
+	const lower = fileName.toLowerCase();
+	if (lower === "init.meta.json" || lower === "init.meta.jsonc") {
+		return null;
+	}
+	if (/\.server\.(luau|lua|clpp)$/i.test(fileName)) {
+		return { name: fileName.replace(/\.server\.(luau|lua|clpp)$/i, ""), className: "Script" };
+	}
+	if (/\.client\.(luau|lua|clpp)$/i.test(fileName)) {
+		return { name: fileName.replace(/\.client\.(luau|lua|clpp)$/i, ""), className: "LocalScript" };
+	}
+	if (/\.plugin\.(luau|lua|clpp)$/i.test(fileName)) {
+		return { name: fileName.replace(/\.plugin\.(luau|lua|clpp)$/i, ""), className: "Script" };
+	}
+	if (/^init\.(luau|lua|clpp|clp)$/i.test(fileName)) {
+		return null;
+	}
+	if (/\.(luau|lua|clpp|clp|clh)$/i.test(fileName)) {
+		return {
+			name: fileName.replace(/\.(luau|lua|clpp|clp|clh)$/i, ""),
+			className: "ModuleScript",
+		};
+	}
+	return null;
+}
+
+function scanFsChildren(absDir: string, parentPath: string, projectRoot: string): Record<string, DatamodelNode> {
+	const children: Record<string, DatamodelNode> = {};
+	if (!fs.existsSync(absDir) || !fs.statSync(absDir).isDirectory()) {
+		return children;
+	}
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(absDir, { withFileTypes: true });
+	} catch {
+		return children;
+	}
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) {
+			continue;
+		}
+		const full = path.join(absDir, entry.name);
+		if (entry.isDirectory()) {
+			const className = readMetaClassName(full) || "Folder";
+			const nodePath = childPath(parentPath, entry.name);
+			children[entry.name] = {
+				name: entry.name,
+				path: nodePath,
+				className,
+				fsPath: posix(path.relative(projectRoot, full) || "."),
+				children: scanFsChildren(full, nodePath, projectRoot),
+			};
+			continue;
+		}
+		if (!entry.isFile()) {
+			continue;
+		}
+		const mapped = classFromFileName(entry.name);
+		if (!mapped || !mapped.name) {
+			continue;
+		}
+		const nodePath = childPath(parentPath, mapped.name);
+		children[mapped.name] = {
+			name: mapped.name,
+			path: nodePath,
+			className: mapped.className,
+			fsPath: posix(path.relative(projectRoot, full)),
+			children: {},
+		};
+	}
+	return children;
+}
+
+function walkNamedNode(node: unknown, name: string, parentPath: string, projectRoot: string): DatamodelNode {
+	const record = asRecord(node) || {};
+	const nodePath = childPath(parentPath, name);
+	const className = typeof record.$className === "string" ? record.$className : "Folder";
+	const fsRel = typeof record.$path === "string" ? record.$path : undefined;
+	const absFs = fsRel ? path.resolve(projectRoot, fsRel) : undefined;
+
+	const children: Record<string, DatamodelNode> = {};
+	for (const [key, child] of Object.entries(record)) {
+		if (key.startsWith("$")) {
+			continue;
+		}
+		children[key] = walkNamedNode(child, key, nodePath, projectRoot);
+	}
+
+	if (absFs && fs.existsSync(absFs) && fs.statSync(absFs).isDirectory()) {
+		const scanned = scanFsChildren(absFs, nodePath, projectRoot);
+		for (const [key, child] of Object.entries(scanned)) {
+			if (!children[key]) {
+				children[key] = child;
+			} else {
+				children[key] = {
+					...children[key],
+					fsPath: children[key].fsPath || child.fsPath,
+					children: { ...child.children, ...children[key].children },
+				};
+			}
+		}
+	}
+
+	return {
+		name,
+		path: nodePath,
+		className,
+		fsPath: fsRel ? posix(fsRel) : undefined,
+		children,
+	};
+}
+
+function indexByPath(node: DatamodelNode, into: Record<string, DatamodelNode>): void {
+	into[node.path] = node;
+	for (const child of Object.values(node.children)) {
+		indexByPath(child, into);
+	}
+}
+
+export function findProjectJson(projectRoot: string, explicit?: string): string | null {
+	const candidates = [
+		explicit,
+		path.join(projectRoot, "default.project.json"),
+		path.join(projectRoot, "default.project.jsonc"),
+	].filter(Boolean) as string[];
+	for (const c of candidates) {
+		const abs = path.resolve(c);
+		if (fs.existsSync(abs)) {
+			return abs;
+		}
+	}
+	return null;
+}
+
+export function buildDatamodelProfile(projectRoot: string, projectJsonPath?: string): DatamodelProfile | null {
+	const jsonPath = findProjectJson(projectRoot, projectJsonPath);
+	if (!jsonPath) {
+		return null;
+	}
+	const raw = parse(fs.readFileSync(jsonPath, "utf8")) as { name?: string; tree?: unknown };
+	const tree = asRecord(raw.tree) || {};
+	const className = typeof tree.$className === "string" ? tree.$className : "DataModel";
+	const children: Record<string, DatamodelNode> = {};
+	for (const [key, child] of Object.entries(tree)) {
+		if (key.startsWith("$")) {
+			continue;
+		}
+		children[key] = walkNamedNode(child, key, "DataModel", projectRoot);
+	}
+
+	const root: DatamodelNode = {
+		name: "DataModel",
+		path: "DataModel",
+		className,
+		children,
+	};
+
+	const byPath: Record<string, DatamodelNode> = {};
+	indexByPath(root, byPath);
+
+	return {
+		schemaVersion: DATAMODEL_SCHEMA_VERSION,
+		projectName: typeof raw.name === "string" ? raw.name : "game",
+		projectJson: posix(path.relative(projectRoot, jsonPath) || path.basename(jsonPath)),
+		root,
+		byPath,
+		generatedAt: new Date().toISOString(),
+	};
+}
+
+export function lookupChild(parent: DatamodelNode, childName: string): DatamodelNode | undefined {
+	return parent.children[childName];
+}
+
+export function resolvePath(profile: DatamodelProfile, segments: string[]): DatamodelNode | null {
+	let node: DatamodelNode = profile.root;
+	for (const seg of segments) {
+		if (seg === "game" || seg === "DataModel") {
+			node = profile.root;
+			continue;
+		}
+		const next = lookupChild(node, seg);
+		if (!next) {
+			return null;
+		}
+		node = next;
+	}
+	return node;
+}
+
+export function listChildNames(node: DatamodelNode): string[] {
+	return Object.keys(node.children).sort();
+}