@cosmicdrift/kumiko-framework 0.2.2 → 0.3.0

package/src/engine/extension-names.ts

@@ -0,0 +1,105 @@
+// Standardisierte Extension-Namen fuer Datenschutz-Hook-Achsen.
+//
+// Features registrieren Extensions via:
+//   r.extendsRegistrar(EXT_USER_DATA, { hooks: { ... } });
+//
+// Andere Features haengen sich ein via:
+//   r.useExtension(EXT_USER_DATA, "myEntity", { ...hookImpls });
+//
+// Hintergrund: Magic-Strings driften zwischen Bundled-Features (Beispiel:
+// text-content nutzt "Admin" als Rolle, tenant-handler nutzt "TenantAdmin").
+// Constants sind die einzige Quelle der Wahrheit; String-Literale werden
+// in den Sprint-Touchpoints schrittweise ersetzt. Boot-Validator
+// (validateExtensionUsages) checkt dass jedes useExtension einen
+// passenden extendsRegistrar findet — Tippfehler in Constants →
+// Compile-Time-Fail.
+//
+// Hook-Signaturen + Boot-Validation pro Extension-Achse kommen mit dem
+// jeweiligen registrierenden Sprint:
+//   userData / tenantData         → Sprint 2 (user-data-rights, retention)
+//   storageProvider                → Sprint 4 (storage-encryption)
+//   searchAdapter / external /     → Sprint 5 (tenant-lifecycle)
+//   infraResource
+
+/**
+ * `userData` — User-Daten-Rights-Hooks (DSGVO Art. 15 + 17 + 20).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `export(userId, ctx) => Promise<UserDataExport>`
+ *   - `delete(userId, strategy: "delete" | "anonymize", ctx) => Promise<void>`
+ *
+ * Registriert von: `user-data-rights` (Sprint 2).
+ * Genutzt von: jedes Feature mit User-Referenzen (tasks, comments, files, ...).
+ */
+export const EXT_USER_DATA = "userData" as const;
+
+/**
+ * `tenantData` — Tenant-Destroy-Hooks pro Entity (DSGVO + AVV-Beendigung).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `destroy(tenantId, ctx) => Promise<void>`
+ *
+ * Registriert von: `tenant-lifecycle` (Sprint 5).
+ * Genutzt von: jedes Feature mit tenantId-Field.
+ */
+export const EXT_TENANT_DATA = "tenantData" as const;
+
+/**
+ * `storageProvider` — File-Storage-Plugin-Hooks (Crypto-Shredding fuer Files).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `destroyTenant(tenantId, ctx) => Promise<void>`
+ *   - `destroySubject(subject, ctx) => Promise<{ deleted: number }>`
+ *
+ * Registriert von: `storage-encryption` (Sprint 4).
+ * Genutzt von: pluggable Provider (Local, MinIO, S3, R2).
+ */
+export const EXT_STORAGE_PROVIDER = "storageProvider" as const;
+
+/**
+ * `searchAdapter` — Search-Adapter-Forget-Hooks (Meilisearch-Index-Cleanup
+ * bei User-Forget oder Tenant-Destroy).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `destroyTenant(tenantId, ctx) => Promise<void>`
+ *   - `eraseSubject(subject, ctx) => Promise<void>`
+ *
+ * Registriert von: `tenant-lifecycle` (Sprint 5).
+ * Genutzt von: Meilisearch- und andere Search-Adapter-Implementierungen.
+ */
+export const EXT_SEARCH_ADAPTER = "searchAdapter" as const;
+
+/**
+ * `externalResource` — External-Service-Tenant-Cleanup
+ * (Webhook-Subscriptions, Brevo-Empfaenger-Listen, Stripe-Customer-Account).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `destroyTenant(tenantId, ctx) => Promise<void>`
+ *
+ * Registriert von: `tenant-lifecycle` (Sprint 5).
+ */
+export const EXT_EXTERNAL_RESOURCE = "externalResource" as const;
+
+/**
+ * `infraResource` — Pulumi-managed Resources pro Tenant
+ * (Custom-Domain, Cert-Manager-Issuer, dedicated Pod/Volume).
+ *
+ * Erwartete Hook-Methoden:
+ *   - `destroyTenant(tenantId, ctx) => Promise<void>`
+ *
+ * Registriert von: `tenant-lifecycle` (Sprint 5).
+ */
+export const EXT_INFRA_RESOURCE = "infraResource" as const;
+
+/**
+ * Union aller standardisierten Extension-Namen der Datenschutz-Surface.
+ * Nicht alle Extensions im System sind in dieser Liste — andere
+ * Features koennen weiterhin eigene Extension-Namen registrieren.
+ */
+export type KumikoExtensionName =
+  | typeof EXT_USER_DATA
+  | typeof EXT_TENANT_DATA
+  | typeof EXT_STORAGE_PROVIDER
+  | typeof EXT_SEARCH_ADAPTER
+  | typeof EXT_EXTERNAL_RESOURCE
+  | typeof EXT_INFRA_RESOURCE;

package/src/engine/extensions/user-data.ts

@@ -0,0 +1,106 @@
+// Hook-Signatur-Types für die EXT_USER_DATA-Extension (DSGVO Art. 15+17+20).
+//
+// Sprint 1.9 Z1: Bisher gibt der Boot-Validator JEDES Hook-Shape durch
+// — useExtension(EXT_USER_DATA, "X", { export: ... }) wird nicht gegen
+// eine erwartete Signatur geprüft. Diese Types sind die canonical
+// Schema-Sicht; Sprint 2 user-data-rights wird sie via
+// `r.extendsRegistrar(EXT_USER_DATA, { hooks: ... })`-Doku exposen.
+//
+// Boot-Time-Schape-Check (Runtime) ist orthogonal und kommt in Sprint
+// 2 wenn die exportRunner-/forgetRunner-Pipelines stehen — bis dahin
+// sind diese Types Compile-Time-Hints für App-Authors, keine Runtime-
+// Validation.
+//
+// Siehe docs/plans/datenschutz/user-data-rights.md.
+
+import type { DbRunner } from "../../db/connection";
+import type { TenantId } from "../types";
+
+// SessionUser.id ist plattformweit `string` (kein Brand-Type). Wenn
+// jemals ein UserId-Brand eingefuehrt wird, ersetzt man hier den
+// inline-Type — andere Codebase-Stellen nutzen denselben Pfad.
+type UserId = string;
+
+/**
+ * Strategie für den Forget-Pfad pro Entity:
+ *   - "delete":    Row physisch entfernen (Profil, Eigene Notizen, Sessions).
+ *   - "anonymize": User-Reference auf null + Display-Felder auf
+ *                  "[Geloescht]" — typisch für geteilte Daten (Tasks,
+ *                  Comments) damit andere User die History nicht verlieren.
+ *
+ * Cleanup-Job (Sprint 2 data-retention) entscheidet pro Entity über
+ * Retention-Policy, welche Strategie greift. blockDelete-Entries lösen
+ * IMMER `anonymize` aus damit Aufbewahrungs-Pflicht respektiert wird.
+ */
+export type UserDataDeleteStrategy = "delete" | "anonymize";
+
+/**
+ * Context-Snapshot der dem Hook übergeben wird. Sprint 2 erweitert
+ * das ggf. um cancel-/timeout-Marker; aktuell minimaler Schnitt.
+ *
+ * `db` ist `DbRunner` (DbConnection | DbTx) damit der Cleanup-Runner
+ * (S2.U5b) den Hook in einer Per-User-Sub-Tx callen kann. Hooks die
+ * raw-DB-Operationen machen funktionieren auf beiden Shapes via
+ * Drizzle's polymorphem select/insert/update/delete-Chain.
+ */
+export interface UserDataHookCtx {
+  readonly db: DbRunner;
+  readonly tenantId: TenantId;
+  readonly userId: UserId;
+}
+
+/**
+ * Pro Feature/Entity-Snippet das im Export-Bundle landet. Sprint 2
+ * orchestriert die JSON-Serialisierung; Hooks geben Plain-Records.
+ */
+export interface UserDataExportSnippet {
+  readonly entity: string;
+  readonly rows: ReadonlyArray<Record<string, unknown>>;
+  /**
+   * Optional: signed-URLs für File-Refs. user-data-rights packt sie
+   * separat ins ZIP unter `files/`. Andere Hooks lassen das leer.
+   */
+  readonly fileRefs?: ReadonlyArray<{
+    readonly fileRefId: string;
+    readonly storageKey: string;
+    readonly fileName: string;
+  }>;
+}
+
+/**
+ * Export-Hook: Sammelt alle Daten einer Entity die zu einem User
+ * gehören. Wird im Daten-Export-Job pro registrierter Entity einmal
+ * aufgerufen. Idempotent — kann mehrfach aufgerufen werden ohne
+ * Side-Effects.
+ *
+ * Sprint 2 user-data-rights ruft das via Iteration über alle
+ * `r.useExtension(EXT_USER_DATA, ...)`-Registrierungen.
+ */
+export type UserDataExportHook = (ctx: UserDataHookCtx) => Promise<UserDataExportSnippet | null>;
+
+/**
+ * Forget-Hook: Löscht oder anonymisiert die Entity-Rows die zu einem
+ * User gehören. Strategy kommt vom Cleanup-Job (kann per Entity
+ * unterschiedlich sein wegen Retention-Policy).
+ *
+ * Idempotent — wenn der Job zweimal läuft (Crash-Recovery), darf der
+ * Hook nicht crashen.
+ */
+export type UserDataDeleteHook = (
+  ctx: UserDataHookCtx,
+  strategy: UserDataDeleteStrategy,
+) => Promise<void>;
+
+/**
+ * Komplette Hook-Tafel für EXT_USER_DATA. Sprint 2 user-data-rights
+ * deklariert das via `r.extendsRegistrar(EXT_USER_DATA, { hooks: ... })`,
+ * konsumierende Features liefern beide Hooks via
+ * `r.useExtension(EXT_USER_DATA, "<entity>", { export, delete })`.
+ *
+ * Kein Hook ist optional — beide MÜSSEN registriert sein. Boot-Check
+ * (Sprint 2) prüft das.
+ */
+export interface UserDataExtensionHooks {
+  readonly export: UserDataExportHook;
+  readonly delete: UserDataDeleteHook;
+}

package/src/engine/factories.ts

@@ -1,8 +1,10 @@
 import type {
+  BigIntFieldDef,
   BooleanFieldDef,
   DateFieldDef,
   EmbeddedFieldDef,
   EntityDefinition,
+  EntityIndexDef,
   FieldsMap,
   FileFieldDef,
   FilesFieldDef,
@@ -13,6 +15,7 @@ import type {
   MoneyFieldDef,
   MultiSelectFieldDef,
   NumberFieldDef,
+  RetentionDef,
   SelectFieldDef,
   TextFieldDef,
   TimestampFieldDef,
@@ -36,7 +39,7 @@ export function createTextField<R extends true | false = false>(
     searchable: false,
     sortable: false,
     ...overrides,
-  } as TextFieldDef & { required: R };
+  } as TextFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 /**
@@ -56,7 +59,7 @@ export function createLongTextField<R extends true | false = false>(
     type: "longText",
     required: false,
     ...overrides,
-  } as LongTextFieldDef & { required: R };
+  } as LongTextFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 export function createBooleanField<R extends true | false = false>(
@@ -67,7 +70,7 @@ export function createBooleanField<R extends true | false = false>(
     required: false,
     default: false,
     ...overrides,
-  } as BooleanFieldDef & { required: R };
+  } as BooleanFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 export function createSelectField<
@@ -82,7 +85,7 @@ export function createSelectField<
     type: "select",
     required: false,
     ...opts,
-  } as SelectFieldDef<TOptions> & { required: R };
+  } as SelectFieldDef<TOptions> & { required: R }; // @cast-boundary engine-payload
 }
 
 /**
@@ -123,7 +126,17 @@ export function createNumberField<R extends true | false = false>(
     type: "number",
     required: false,
     ...overrides,
-  } as NumberFieldDef & { required: R };
+  } as NumberFieldDef & { required: R }; // @cast-boundary engine-payload
+}
+
+export function createBigIntField<R extends true | false = false>(
+  overrides?: Partial<Omit<BigIntFieldDef, "type" | "required">> & { required?: R },
+): BigIntFieldDef & { required: R } {
+  return {
+    type: "bigInt",
+    required: false,
+    ...overrides,
+  } as BigIntFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 export function createMoneyField<R extends true | false = false>(
@@ -132,7 +145,7 @@ export function createMoneyField<R extends true | false = false>(
   return {
     type: "money",
     ...overrides,
-  } as MoneyFieldDef & { required: R };
+  } as MoneyFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 export function createEmbeddedField(
@@ -153,7 +166,7 @@ export function createDateField<R extends true | false = false>(
     type: "date",
     required: false,
     ...overrides,
-  } as DateFieldDef & { required: R };
+  } as DateFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 /**
@@ -173,7 +186,7 @@ export function createTimestampField<R extends true | false = false>(
   return {
     ...overrides,
     type: "timestamp",
-    required: (overrides?.required ?? false) as R,
+    required: (overrides?.required ?? false) as R, // @cast-boundary engine-payload
   };
 }
 
@@ -188,7 +201,7 @@ export function createTzField<R extends true | false = false>(
     type: "tz",
     required: false,
     ...overrides,
-  } as TzFieldDef & { required: R };
+  } as TzFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 /**
@@ -228,7 +241,7 @@ export function createLocatedTimestampField<R extends true | false = false>(
     type: "locatedTimestamp",
     required: false,
     ...overrides,
-  } as LocatedTimestampFieldDef & { required: R };
+  } as LocatedTimestampFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
 /**
@@ -309,13 +322,10 @@ export function createEntity<F>(def: {
   readonly searchWeight?: number;
   readonly defaultCurrency?: string;
   readonly transitions?: Readonly<Record<string, Readonly<Record<string, readonly string[]>>>>;
-  readonly indexes?: readonly {
-    readonly columns: readonly [string, ...string[]];
-    readonly unique?: boolean;
-    readonly name?: string;
-  }[];
+  readonly indexes?: readonly EntityIndexDef[];
   readonly idType?: "serial" | "uuid";
   readonly access?: EntityDefinition["access"];
+  readonly retention?: RetentionDef;
 }): F extends FieldsMap ? EntityDefinition<F> : never {
   return {
     softDelete: false,
@@ -324,5 +334,5 @@ export function createEntity<F>(def: {
     // aggregate-ids are UUID. Opt-out with `idType: "serial"` for pre-ES
     // legacy tables (should be rare).
     ...def,
-  } as F extends FieldsMap ? EntityDefinition<F> : never;
+  } as F extends FieldsMap ? EntityDefinition<F> : never; // @cast-boundary engine-payload
 }

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

@@ -0,0 +1,184 @@
+// 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 { Project } from "ts-morph";
+import { describe, expect, test } from "vitest";
+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);
+  });
+});

package/src/engine/feature-ast/extractors/index.ts

@@ -0,0 +1,74 @@
+export {
+  extractOptionalRequires,
+  extractReadsConfig,
+  extractRequires,
+  extractSystemScope,
+  extractToggleable,
+} from "./round1";
+export {
+  extractEntity,
+  extractNav,
+  extractRelation,
+  extractWorkspace,
+} from "./round2";
+export {
+  extractClaimKey,
+  extractConfig,
+  extractMetric,
+  extractReferenceData,
+  extractSecret,
+  extractTranslations,
+  extractUseExtension,
+  isClaimKeyType,
+  type NamedOptionsResult,
+  readNamedOptions,
+} from "./round3";
+export {
+  collectScreenOpaqueProps,
+  extractAuthClaims,
+  extractDefineEvent,
+  extractEntityHook,
+  extractEventMigration,
+  extractHook,
+  extractHttpRoute,
+  extractJob,
+  extractMultiStreamProjection,
+  extractNotification,
+  extractProjection,
+  extractQueryHandler,
+  extractScreen,
+  extractWriteHandler,
+  isEntityHookType,
+  isHookType,
+  isHttpRouteMethod,
+  type ParsedHandlerCall,
+  parseHandlerCall,
+  readApplyBodies,
+  readOptionalAccessRule,
+  readOptionalPhase,
+  readOptionalRateLimit,
+  readScreenStatic,
+} from "./round4";
+export {
+  extractExposesApi,
+  extractExtendsRegistrar,
+  extractUsesApi,
+} from "./round5";
+export {
+  extractTree,
+  extractTreeActions,
+} from "./round6";
+export type { ExtractOutput } from "./shared";
+export {
+  fail,
+  findFunctionLiteral,
+  isPlainObject,
+  ok,
+  readBooleanProperty,
+  readDataLiteralNode,
+  readNameOrRef,
+  readNameOrRefOrList,
+  readPropertyKey,
+  readStringLiteralArgs,
+  readVarargsOrArrayProp,
+} from "./shared";