@cosmicdrift/kumiko-framework 0.133.0 → 0.134.0

package/src/observability/__tests__/recording-tracer.test.ts

@@ -87,11 +87,13 @@ describe("RecordingTracer", () => {
     expect(recorded).toHaveLength(1);
   });
 
-  it("startSpanFromContext continues an upstream trace", () => {
+  it("startSpan with parent context continues an upstream trace", () => {
     const { tracer, recorded } = makeTracer();
-    const span = tracer.startSpanFromContext("child", {
-      traceId: "aabbccddeeff00112233445566778899",
-      spanId: "1122334455667788",
+    const span = tracer.startSpan("child", {
+      parent: {
+        traceId: "aabbccddeeff00112233445566778899",
+        spanId: "1122334455667788",
+      },
     });
     span.end();
     expect(recorded[0]?.traceId).toBe("aabbccddeeff00112233445566778899");

package/src/observability/noop-provider.ts

@@ -5,7 +5,6 @@ import type {
   Meter,
   MetricDefinition,
   ObservabilityProvider,
-  SerializedTraceContext,
   Span,
   SpanStatus,
   StartSpanOptions,
@@ -68,14 +67,6 @@ class NoopTracer implements Tracer {
   getActiveSpan(): Span | undefined {
     return undefined;
   }
-
-  startSpanFromContext(
-    name: string,
-    _context: SerializedTraceContext,
-    _options?: StartSpanOptions,
-  ): Span {
-    return new NoopSpan(name, undefined);
-  }
 }
 
 class NoopCounter implements Counter {

package/src/observability/recording-tracer.ts

@@ -175,18 +175,6 @@ export class RecordingTracer implements Tracer {
   getActiveSpan(): Span | undefined {
     return observabilityContext.getActiveSpan();
   }
-
-  /**
-   * @deprecated Prefer `startSpan(name, { parent: context })`. Retained as a
-   *   thin alias for call-sites that pre-date the unified StartSpanOptions.
-   */
-  startSpanFromContext(
-    name: string,
-    context: SerializedTraceContext,
-    options?: StartSpanOptions,
-  ): Span {
-    return this.startSpan(name, { ...options, parent: context });
-  }
 }
 
 // Helper to serialize an active Span into the cross-process format.

package/src/observability/types/span.ts

@@ -55,10 +55,4 @@ export interface Tracer {
   ): Promise<T>;
   // Current active span from AsyncLocalStorage, or undefined.
   getActiveSpan(): Span | undefined;
-  // @deprecated Prefer `startSpan(name, { parent: context })`.
-  startSpanFromContext(
-    name: string,
-    context: SerializedTraceContext,
-    options?: StartSpanOptions,
-  ): Span;
 }

package/src/time/tz-context.ts

@@ -17,7 +17,7 @@
 import type { GeoAddress, GeoCoordinates, GeoTzProvider } from "./geo-tz";
 import { ensureTemporalPolyfill, getTemporal } from "./polyfill";
 
-// JSON-Form für Wall-Clock+TZ — siehe locatedTimestamp(name) Helper in
+// JSON-Form für Wall-Clock+TZ — siehe createLocatedTimestampField() in
 // engine/factories.ts. Zwei Felder, idiotensicher.
 export type LocatedTimestampJson = {
   /** Wall-Clock-ISO ohne Offset, z.B. "2026-04-03T10:00:00" */

package/src/ui-types/index.ts

@@ -47,9 +47,14 @@ export type {
   CustomScreenDefinition,
   CustomScreenRoute,
   DashboardChartPanel,
+  DashboardCustomPanel,
+  DashboardFeedPanel,
+  DashboardFilterDefinition,
   DashboardListPanel,
   DashboardPanelDefinition,
+  DashboardProgressListPanel,
   DashboardScreenDefinition,
+  DashboardStatGroupPanel,
   DashboardStatPanel,
   EditExtensionSection,
   EditFieldSpec,

package/src/bun-db/__tests__/bun-test-stack.ts

@@ -1,6 +0,0 @@
-// Provider-agnostic Test-Stack — re-exported from stack/test-stack.ts.
-// setupBunTestStack / BunTestStack sind Aliase für setupTestStack / TestStack.
-// "Bun" ist historisch, jetzt provider-neutral (DB_PROVIDER env).
-
-export type { TestStack as BunTestStack } from "../../stack/test-stack";
-export { setupTestStack as setupBunTestStack } from "../../stack/test-stack";

package/src/db/row-helpers.ts

@@ -1,4 +0,0 @@
-// Legacy re-export shim — fetchOne lebt jetzt in src/bun-db/query.ts.
-
-export type { WhereObject } from "../db/query";
-export { fetchOne } from "../db/query";

package/src/engine/feature-ast/__tests__/visual-tree-parse.test.ts

@@ -1,184 +0,0 @@
-// AST round-trip tests for the Visual-Tree patterns. Each test feeds
-// a minimal inline-feature into parseSourceFile and asserts the
-// extracted Pattern shape + the editability classification.
-//
-// Why split from visual-tree-patterns.test.ts (engine-level): that suite
-// covers the registrar+registry runtime path. This suite covers the
-// AST extractor + the Designer/AI consumers (renderPattern,
-// getEditability, PATTERN_LIBRARY). Both halves must agree on shape.
-
-import { describe, expect, test } from "bun:test";
-import { Project } from "ts-morph";
-import { parseSourceFile } from "../parse";
-import { getEditability } from "../patterns";
-import { renderPattern } from "../render";
-
-function parseInline(source: string) {
-  const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: true });
-  const sourceFile = project.createSourceFile("feature.ts", source);
-  return parseSourceFile(sourceFile);
-}
-
-describe("parseSourceFile — r.treeActions extraction", () => {
-  test("extracts a static treeActions pattern from an inline action-map", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("text-content", (r) => {
-        r.treeActions({
-          edit: { args: { slug: "" as string } },
-          list: {},
-        });
-      });
-    `);
-
-    expect(result.errors).toEqual([]);
-    const treeActions = result.patterns.find((p) => p.kind === "treeActions");
-    expect(treeActions).toBeDefined();
-    expect(treeActions?.kind).toBe("treeActions");
-    if (treeActions?.kind === "treeActions") {
-      expect(treeActions.definitions).toEqual({
-        edit: { args: { slug: "" } },
-        list: {},
-      });
-    }
-  });
-
-  test("treeActions pattern is classified as static (Designer renders form)", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => { r.treeActions({ list: {} }); });
-    `);
-    const treeActions = result.patterns.find((p) => p.kind === "treeActions");
-    expect(treeActions).toBeDefined();
-    if (treeActions !== undefined) {
-      expect(getEditability(treeActions)).toBe("static");
-    }
-  });
-
-  test("missing first argument produces a parse-error, not a pattern", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => { r.treeActions(); });
-    `);
-    expect(result.patterns.find((p) => p.kind === "treeActions")).toBeUndefined();
-    expect(result.errors.some((e) => e.methodName === "treeActions")).toBe(true);
-  });
-
-  test("non-object first argument (identifier ref) produces a parse-error", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      const actions = { list: {} };
-      defineFeature("x", (r) => { r.treeActions(actions); });
-    `);
-    expect(result.patterns.find((p) => p.kind === "treeActions")).toBeUndefined();
-    expect(result.errors.some((e) => e.methodName === "treeActions")).toBe(true);
-  });
-
-  test("renderPattern round-trips back to a valid r.treeActions(...) call", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => {
-        r.treeActions({ edit: { args: { slug: "" } }, list: {} });
-      });
-    `);
-    const treeActions = result.patterns.find((p) => p.kind === "treeActions");
-    expect(treeActions).toBeDefined();
-    if (treeActions !== undefined) {
-      const rendered = renderPattern(treeActions);
-      expect(rendered).toMatch(/^r\.treeActions\(/);
-      // renderValue darf identifier-safe Keys unquoted ausgeben — beide
-      // Schreibweisen sind valide TypeScript-Source.
-      expect(rendered).toMatch(/(["])edit\1|edit\s*:/);
-      expect(rendered).toMatch(/(["])slug\1|slug\s*:/);
-    }
-  });
-});
-
-describe("parseSourceFile — r.tree extraction", () => {
-  test("extracts an opaque tree pattern with the provider body as SourceLocation", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("text-content", (r) => {
-        r.tree((ctx) => (emit) => {
-          emit([{ label: "Marketing" }]);
-          return () => {};
-        });
-      });
-    `);
-
-    expect(result.errors).toEqual([]);
-    const tree = result.patterns.find((p) => p.kind === "tree");
-    expect(tree).toBeDefined();
-    if (tree?.kind === "tree") {
-      expect(tree.providerBody.raw).toContain("emit");
-      expect(tree.providerBody.raw).toContain("Marketing");
-    }
-  });
-
-  test("tree pattern is classified as opaque (Designer renders read-only code-block)", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => { r.tree((ctx) => (emit) => () => {}); });
-    `);
-    const tree = result.patterns.find((p) => p.kind === "tree");
-    expect(tree).toBeDefined();
-    if (tree !== undefined) {
-      expect(getEditability(tree)).toBe("opaque");
-    }
-  });
-
-  test("missing first argument produces a parse-error, not a pattern", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => { r.tree(); });
-    `);
-    expect(result.patterns.find((p) => p.kind === "tree")).toBeUndefined();
-    expect(result.errors.some((e) => e.methodName === "tree")).toBe(true);
-  });
-
-  test("non-function first argument (identifier ref) produces a parse-error", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      const provider = (ctx: unknown) => (emit: unknown) => () => {};
-      defineFeature("x", (r) => { r.tree(provider); });
-    `);
-    expect(result.patterns.find((p) => p.kind === "tree")).toBeUndefined();
-    expect(result.errors.some((e) => e.methodName === "tree")).toBe(true);
-  });
-
-  test("renderPattern round-trips back to a valid r.tree(...) call with the body verbatim", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("x", (r) => {
-        r.tree((ctx) => (emit) => { emit([]); return () => {}; });
-      });
-    `);
-    const tree = result.patterns.find((p) => p.kind === "tree");
-    expect(tree).toBeDefined();
-    if (tree !== undefined) {
-      const rendered = renderPattern(tree);
-      expect(rendered).toMatch(/^r\.tree\(/);
-      expect(rendered).toContain("emit");
-    }
-  });
-});
-
-describe("Combined — feature with both r.treeActions and r.tree", () => {
-  test("both patterns coexist in the parse output, source-order preserved", () => {
-    const result = parseInline(`
-      import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-      defineFeature("text-content", (r) => {
-        r.treeActions({ edit: { args: { slug: "" } } });
-        r.tree((ctx) => (emit) => { emit([{ label: "Marketing" }]); return () => {}; });
-      });
-    `);
-
-    expect(result.errors).toEqual([]);
-    const kinds = result.patterns.map((p) => p.kind);
-    const idxActions = kinds.indexOf("treeActions");
-    const idxTree = kinds.indexOf("tree");
-    expect(idxActions).toBeGreaterThanOrEqual(0);
-    expect(idxTree).toBeGreaterThanOrEqual(0);
-    expect(idxActions).toBeLessThan(idxTree);
-  });
-});