@kumikijs/compiler 0.3.1 → 0.5.0

package/dist/index.d.ts

@@ -469,6 +469,12 @@ declare function parseCapabilityManifest(raw: unknown): ManifestResult;
 type CodegenOptions = {
   runtimeSpecifier: string; /** Emit the in-language `test` definitions (`__kumikiTests`). Off for production builds. */
   includeTests?: boolean;
+  /**
+   * Emit `export default App;` instead of auto-mounting to `#root`. Use when the
+   * module is imported (e.g. the Vite plugin / Web Component embedding) rather
+   * than run as a standalone page bundle.
+   */
+  exportApp?: boolean;
 };
 declare function codegen(program: Program, opts: CodegenOptions): string;
 /**
@@ -539,6 +545,14 @@ type ExtendedCodegenOptions = CodegenOptions & {
 declare function inlineRuntime(generatedJs: string, runtimeBundleJs: string): string;
 declare function compile(source: string, opts: ExtendedCodegenOptions): CompileResult;
 //#endregion
+//#region src/dts.d.ts
+/**
+ * Generate a TypeScript declaration for a Kumiki program's slot/effect/type
+ * surface. Returns module source (importing nothing) suitable for writing next
+ * to the `.kumiki` file and importing for typed provider authoring.
+ */
+declare function generateDts(program: Program): string;
+//#endregion
 //#region src/lexer.d.ts
 declare function lex(source: string): Token[];
 //#endregion
@@ -549,4 +563,4 @@ declare class ParseError extends Error {
 }
 declare function parse(tokens: Token[]): Program;
 //#endregion
-export { type AppDef, type BinOp, type CapabilityManifest, type CodegenOptions, type CompileFail, type CompileOk, type CompileResult, type Def, type EffectDef, type EventPattern, type Expr, type ExtendedCodegenOptions, FIELD_ACCESS_SHORTCUTS, type FnDef, KNOWN_MEMBERS, KNOWN_METHODS, type KumikiError, type Lvalue, type ManifestResult, type MatchArm, type MotionDef, ParseError, type Pattern, type PolicyExpr, type Pos, type Program, RUNTIME_HELPERS, type ReducerDef, type Refinement, type RetryExpr, STANDARD_CAPABILITIES, type SlotDef, type Statement, type TestDef, type ThemeDef, type ThemeValue, type TileArg, type TileDef, type TileExpr, type TileMatchArm, type TileProp, type Token, type TypeDef, type TypeExpr, type UiEventKind, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };
+export { type AppDef, type BinOp, type CapabilityManifest, type CodegenOptions, type CompileFail, type CompileOk, type CompileResult, type Def, type EffectDef, type EventPattern, type Expr, type ExtendedCodegenOptions, FIELD_ACCESS_SHORTCUTS, type FnDef, KNOWN_MEMBERS, KNOWN_METHODS, type KumikiError, type Lvalue, type ManifestResult, type MatchArm, type MotionDef, ParseError, type Pattern, type PolicyExpr, type Pos, type Program, RUNTIME_HELPERS, type ReducerDef, type Refinement, type RetryExpr, STANDARD_CAPABILITIES, type SlotDef, type Statement, type TestDef, type ThemeDef, type ThemeValue, type TileArg, type TileDef, type TileExpr, type TileMatchArm, type TileProp, type Token, type TypeDef, type TypeExpr, type UiEventKind, check, codegen, compile, generateDts, inlineRuntime, lex, parse, parseCapabilityManifest };

package/dist/index.js

@@ -26,6 +26,7 @@ function codegen(program, opts) {
 	lines.push("");
 	lines.push("const _s = _stdlib;");
 	lines.push("");
+	lines.push("function createApp() {");
 	for (const fn of fns) lines.push(genFn(fn, ctx));
 	lines.push("const _effects = {");
 	for (const eff of effects) lines.push(`  ${JSON.stringify(eff.name)}: ${genEffect(eff, ctx)},`);
@@ -78,21 +79,29 @@ function codegen(program, opts) {
 	lines.push(`  themeName: ${themeRef},`);
 	lines.push("  motions: _motions,");
 	lines.push("};");
-	lines.push("");
-	lines.push("globalThis.__kumikiApp = App;");
 	if (opts.includeTests && tests.length > 0) {
-		lines.push("");
 		lines.push("const _tilesById = {");
 		for (const tile of tiles) lines.push(`  ${JSON.stringify(tile.name)}: (${jsName("$1")}) => ${genTile(tile, ctx)},`);
 		lines.push("};");
-		lines.push("void _tilesById;");
+		lines.push("App._tilesById = _tilesById;");
+	}
+	lines.push("  return App;");
+	lines.push("}");
+	lines.push("");
+	lines.push("const App = createApp();");
+	lines.push("globalThis.__kumikiApp = App;");
+	if (opts.includeTests && tests.length > 0) {
+		lines.push("");
 		lines.push("const __kumikiTests = [");
 		for (const t of tests) lines.push(genTest(t, ctx));
 		lines.push("];");
 		lines.push("globalThis.__kumikiTests = __kumikiTests;");
 	}
 	lines.push("");
-	lines.push(`mount(App, document.getElementById("root"));`);
+	if (opts.exportApp) {
+		lines.push("export default App;");
+		lines.push("export { createApp };");
+	} else lines.push(`mount(App, document.getElementById("root"), { providers: globalThis.__kumikiProviders, ...globalThis.__kumikiMount });`);
 	return lines.join("\n");
 }
 function recordField(e, name) {
@@ -119,14 +128,14 @@ function genTest(t, gen) {
     name: ${nameJs},
     kind: "reducer-test",
     run: () => {
-      _s.resetLive(_live, _slots, ${slotsJs});
+      _s.resetLive(App.live, App.slots, ${slotsJs});
       const _el = ${elJs};
-      const _r = _reducers.find((r) => r.name === ${JSON.stringify(t.target)});
+      const _r = App.reducers.find((r) => r.name === ${JSON.stringify(t.target)});
       if (!_r) throw new Error("reducer ${t.target} not found");
       let _res = null, _panic = null;
-      try { _res = _r.apply(_live, { $el: _el, $event: _el }); }
+      try { _res = _r.apply(App.live, { $el: _el, $event: _el }); }
       catch (e) { _panic = (e && e.message) ? e.message : String(e); }
-      return _s.runReducerTest({ name: ${nameJs}, givenSlots: { ..._live }, result: _res, panic: _panic, expect: ${expectJs} });
+      return _s.runReducerTest({ name: ${nameJs}, givenSlots: { ...App.live }, result: _res, panic: _panic, expect: ${expectJs} });
     },
   },`;
 	}
@@ -139,8 +148,8 @@ function genTest(t, gen) {
     name: ${nameJs},
     kind: "tile-test",
     run: () => {
-      _s.resetLive(_live, _slots, ${slotsJs});
-      const _actual = _tilesById[${JSON.stringify(t.target)}](${inJs});
+      _s.resetLive(App.live, App.slots, ${slotsJs});
+      const _actual = App._tilesById[${JSON.stringify(t.target)}](${inJs});
       const _expected = ${expectedJs};
       return _s.runTileTest({ name: ${nameJs}, actual: _actual, expected: _expected });
     },
@@ -196,23 +205,29 @@ function genFn(fn, gen) {
 	]));
 	return `function ${jsName(fn.name)}(${params}) { return ${jsOfExpr(fn.body, ctx)}; }`;
 }
+/**
+* The built-in implementation call for a standard capability, given the request
+* variable name. Returns null for custom capabilities (no built-in — a host
+* provider is required).
+*/
+function builtinEffectCall(eff, reqVar) {
+	if (eff.cap === "storage.read") return `builtinEffects.storageRead(${eff.mapRequest ? `{ key: ${reqVar}.key }` : reqVar})`;
+	if (eff.cap === "storage.write") return `builtinEffects.storageWrite(${eff.mapRequest ? `{ key: ${reqVar}.key, value: ${reqVar}.value }` : reqVar})`;
+	if (eff.cap.startsWith("http.")) {
+		const method = eff.cap.slice(5).toUpperCase();
+		return `builtinEffects.httpFetch(${JSON.stringify(method)}, ${reqVar}, "")`;
+	}
+	return null;
+}
 function genEffect(eff, gen) {
+	const capJs = JSON.stringify(eff.cap);
+	const reqVar = eff.mapRequest ? "req" : "input";
+	const tail = `const p = caps.provider(${capJs}); if (p) return p(${reqVar}, caps); return ${builtinEffectCall(eff, reqVar) ?? `{ kind: "err", value: { message: ${JSON.stringify(`Capability ${eff.cap} has no provider`)} } }`};`;
 	let invokeBody;
-	if (eff.cap === "storage.read") if (eff.mapRequest) {
-		const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
-		invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.storageRead({ key: req.key }); }`;
-	} else invokeBody = `async (input) => builtinEffects.storageRead(input)`;
-	else if (eff.cap === "storage.write") if (eff.mapRequest) {
+	if (eff.mapRequest) {
 		const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
-		invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.storageWrite({ key: req.key, value: req.value }); }`;
-	} else invokeBody = `async (input) => builtinEffects.storageWrite(input)`;
-	else if (eff.cap.startsWith("http.")) {
-		const method = eff.cap.slice(5).toUpperCase();
-		if (eff.mapRequest) {
-			const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
-			invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.httpFetch(${JSON.stringify(method)}, req, ""); }`;
-		} else invokeBody = `async (input) => builtinEffects.httpFetch(${JSON.stringify(method)}, input, "")`;
-	} else invokeBody = `async () => ({ kind: "err", value: { message: "Capability ${eff.cap} not implemented" } })`;
+		invokeBody = `async (${jsName("$1")}, caps) => { const req = ${mapJs}; ${tail} }`;
+	} else invokeBody = `async (input, caps) => { ${tail} }`;
 	return `{
     name: ${JSON.stringify(eff.name)},
     cap: ${JSON.stringify(eff.cap)},
@@ -4038,4 +4053,100 @@ function compile(source, opts) {
 	};
 }
 //#endregion
-export { FIELD_ACCESS_SHORTCUTS, KNOWN_MEMBERS, KNOWN_METHODS, ParseError, RUNTIME_HELPERS, STANDARD_CAPABILITIES, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };
+//#region src/dts.ts
+const PRIM_TS = {
+	Int: "number",
+	Float: "number",
+	Time: "number",
+	Text: "string",
+	Bool: "boolean",
+	Unit: "null",
+	Bytes: "Uint8Array"
+};
+const KNOWN_SCALAR = {
+	Url: "string",
+	Email: "string",
+	Uuid: "string",
+	HttpStatus: "number",
+	Duration: "number"
+};
+function tsOfType(t, ctx) {
+	switch (t.kind) {
+		case "TypePrim": return PRIM_TS[t.name] ?? "unknown";
+		case "TypeRef":
+			if (ctx.userTypes.has(t.name)) return t.name;
+			return KNOWN_SCALAR[t.name] ?? "unknown";
+		case "TypeApp": {
+			const arg = (i) => t.args[i] ? tsOfType(t.args[i], ctx) : "unknown";
+			switch (t.name) {
+				case "List": return `${wrap(arg(0))}[]`;
+				case "Map": return `Record<string, ${arg(1)}>`;
+				case "Set": return "Record<string, true>";
+				case "Option": return `{ _tag: "Some"; _0: ${arg(0)} } | { _tag: "None" }`;
+				case "Result": return `{ _tag: "Ok"; _0: ${arg(0)} } | { _tag: "Err"; _0: ${arg(1)} }`;
+				case "Tuple": return `[${t.args.map((a) => tsOfType(a, ctx)).join(", ")}]`;
+				default: return "unknown";
+			}
+		}
+		case "TypeRecord": return `{ ${t.fields.map((f) => `${f.name}: ${tsOfType(f.type, ctx)}`).join("; ")} }`;
+		case "TypeUnion": return t.variants.map((v) => variantTs(v.name, v.payloads, ctx)).join(" | ");
+		case "TypeNominal":
+		case "TypeRefinement": return tsOfType(t.inner, ctx);
+		default: return "unknown";
+	}
+}
+/** One tagged variant: `{ _tag: "Name" }` or `{ _tag: "Name"; _0: P0; … }`. */
+function variantTs(name, payloads, ctx) {
+	if (payloads.length === 0) return `{ _tag: ${JSON.stringify(name)} }`;
+	const fields = payloads.map((p, i) => `_${i}: ${tsOfType(p, ctx)}`).join("; ");
+	return `{ _tag: ${JSON.stringify(name)}; ${fields} }`;
+}
+/** Parenthesize a union so `T[]` binds correctly (`(A | null)[]`). */
+function wrap(ts) {
+	return ts.includes("|") ? `(${ts})` : ts;
+}
+/**
+* Generate a TypeScript declaration for a Kumiki program's slot/effect/type
+* surface. Returns module source (importing nothing) suitable for writing next
+* to the `.kumiki` file and importing for typed provider authoring.
+*/
+function generateDts(program) {
+	const types = program.defs.filter((d) => d.kind === "TypeDef");
+	const slots = program.defs.filter((d) => d.kind === "SlotDef");
+	const effects = program.defs.filter((d) => d.kind === "EffectDef");
+	const ctx = { userTypes: new Set(types.map((t) => t.name)) };
+	const out = [];
+	out.push("// Auto-generated by @kumikijs/compiler from the .kumiki source. Do not edit.");
+	out.push("");
+	out.push("/** A typed host implementation for one custom capability. */");
+	out.push("export type Provider<In, Out> = (");
+	out.push("  input: In,");
+	out.push("  caps: { has(c: string): boolean; provider(c: string): unknown },");
+	out.push(") =>");
+	out.push("  | { kind: 'ok'; value: Out }");
+	out.push("  | { kind: 'err'; value: unknown }");
+	out.push("  | Promise<{ kind: 'ok'; value: Out } | { kind: 'err'; value: unknown }>;");
+	out.push("");
+	for (const t of types) {
+		const params = t.params.length > 0 ? `<${t.params.join(", ")}>` : "";
+		out.push(`export type ${t.name}${params} = ${tsOfType(t.body, ctx)};`);
+	}
+	if (types.length > 0) out.push("");
+	out.push("export interface Slots {");
+	for (const s of slots) out.push(`  ${s.name}: ${tsOfType(s.type, ctx)};`);
+	out.push("}");
+	out.push("");
+	const custom = effects.filter((e) => !STANDARD_CAPABILITIES.has(e.cap));
+	out.push("/** Host implementations for this app's custom capabilities. */");
+	out.push("export interface Providers {");
+	for (const e of custom) {
+		const input = tsOfType(e.inType, ctx);
+		const output = tsOfType(e.outType, ctx);
+		out.push(`  ${JSON.stringify(e.cap)}?: Provider<${input}, ${output}>;`);
+	}
+	out.push("}");
+	out.push("");
+	return out.join("\n");
+}
+//#endregion
+export { FIELD_ACCESS_SHORTCUTS, KNOWN_MEMBERS, KNOWN_METHODS, ParseError, RUNTIME_HELPERS, STANDARD_CAPABILITIES, check, codegen, compile, generateDts, inlineRuntime, lex, parse, parseCapabilityManifest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumikijs/compiler",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "type": "module",
   "description": "Kumiki compiler — lexer, parser, typechecker, and code generator.",
   "license": "Apache-2.0",
@@ -41,7 +41,7 @@
     "provenance": true
   },
   "dependencies": {
-    "@kumikijs/runtime": "0.3.0"
+    "@kumikijs/runtime": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",