@dowel-ui/registry 0.5.0 → 0.7.0

package/src/generate.ts

@@ -0,0 +1,500 @@
+import type { RegistryIndex, RegistryIndexEntry } from "./schema";
+
+export type { RegistryIndex, RegistryIndexEntry } from "./schema";
+
+/**
+ * Turning a description of a screen into a plan made of components that exist.
+ *
+ * The hard part of generating UI is not writing JSX. It is not inventing: a
+ * model asked for a billing page will cheerfully produce `<PricingTable>` and
+ * `<InvoiceList>` and a `variant="subtle"` that was never implemented, and the
+ * result reads perfectly and compiles nowhere.
+ *
+ * So this resolves a prompt against the registry first, and everything it
+ * emits afterwards is drawn from what came back. It cannot name a component
+ * that is not installable, because it only ever repeats names the registry
+ * gave it.
+ *
+ * It does not guess at props. The registry publishes what a component *is* and
+ * what it depends on, not the shape of its arguments, so the output stops at
+ * the composition and points at the page where the props are documented.
+ * Emitting a plausible prop is worse than emitting none — one is a gap, the
+ * other is a bug that looks like working code.
+ */
+
+/** Words that carry no signal about which component is wanted. */
+const STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "for",
+  "with",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "is",
+  "are",
+  "be",
+  "make",
+  "build",
+  "create",
+  "want",
+  "need",
+  "add",
+  "show",
+  "page",
+  "screen",
+  "app",
+  "application",
+  "ui",
+  "interface",
+  "component",
+  "components",
+  "me",
+  "my",
+  "our",
+  "i",
+  "it",
+  "that",
+  "this",
+  "some",
+  "using",
+  "use",
+  "like",
+]);
+
+/**
+ * Words a reader would use that are not the words the registry uses.
+ *
+ * Hand-written, and deliberately so. "Sign in" is what someone types and
+ * `login` is what the item is called; no amount of string similarity bridges
+ * that, and pretending otherwise produces a matcher that works on the examples
+ * it was tuned against and nothing else.
+ */
+const SYNONYMS: Record<string, string[]> = {
+  "sign in": ["login"],
+  signin: ["login"],
+  "log in": ["login"],
+  "sign up": ["signup"],
+  register: ["signup"],
+  registration: ["signup"],
+  "forgot password": ["forgot-password"],
+  "reset password": ["forgot-password"],
+  chat: ["ai-chat", "ai-conversation", "ai-prompt-input"],
+  conversation: ["ai-chat"],
+  assistant: ["ai-chat"],
+  copilot: ["ai-chat"],
+  agent: ["agent-console", "ai-agent-status", "ai-agent-plan"],
+  agents: ["agent-console"],
+  tool: ["ai-tool"],
+  approval: ["ai-approval-request"],
+  approve: ["ai-approval-request"],
+  undo: ["ai-action-ledger"],
+  audit: ["ai-action-ledger", "activity-feed"],
+  tokens: ["ai-token-usage"],
+  spend: ["ai-dashboard", "billing"],
+  cost: ["ai-dashboard", "billing"],
+  usage: ["ai-dashboard", "billing"],
+  subscription: ["billing", "pricing"],
+  invoice: ["billing"],
+  invoices: ["billing"],
+  payment: ["billing"],
+  plan: ["pricing", "billing"],
+  plans: ["pricing"],
+  metrics: ["analytics", "dashboard", "metric-delta"],
+  chart: ["analytics"],
+  charts: ["analytics"],
+  graph: ["analytics"],
+  stats: ["dashboard", "analytics"],
+  overview: ["dashboard"],
+  grid: ["data-table", "table"],
+  spreadsheet: ["data-table"],
+  list: ["table", "data-table"],
+  search: ["command", "combobox"],
+  palette: ["command"],
+  shortcut: ["command", "shortcut-recorder"],
+  modal: ["dialog"],
+  popup: ["dialog", "popover"],
+  dropdown: ["dropdown-menu", "select"],
+  toast: ["toast"],
+  notification: ["toast", "activity-feed"],
+  notifications: ["toast", "settings"],
+  upload: ["file-upload"],
+  file: ["file-upload"],
+  date: ["date-picker", "calendar"],
+  time: ["time-range-picker"],
+  schedule: ["cron-editor"],
+  cron: ["cron-editor"],
+  team: ["admin-users", "settings"],
+  members: ["admin-users"],
+  users: ["admin-users"],
+  admin: ["admin-users"],
+  permissions: ["permission-matrix"],
+  roles: ["permission-matrix"],
+  profile: ["settings"],
+  preferences: ["settings"],
+  account: ["settings", "billing"],
+  setup: ["onboarding"],
+  checklist: ["onboarding"],
+  wizard: ["onboarding"],
+  logs: ["log-viewer"],
+  log: ["log-viewer"],
+  diff: ["diff-viewer", "record-diff"],
+  secret: ["secret-field"],
+  "api key": ["secret-field"],
+  key: ["secret-field"],
+  dns: ["dns-record"],
+};
+
+export interface PlanEntry {
+  entry: RegistryIndexEntry;
+  /** Why this was chosen, in words, so a wrong pick is arguable. */
+  because: string;
+}
+
+export interface UiPlan {
+  /** The prompt, as given. */
+  prompt: string;
+  /** Whole sections, which bring their own components. */
+  blocks: PlanEntry[];
+  /** Individual components, none of which a chosen block already installs. */
+  components: PlanEntry[];
+  /** Everything to install, in one list. */
+  install: string[];
+  /** True when nothing matched, so callers can say so rather than emit nothing. */
+  empty: boolean;
+}
+
+function normalise(prompt: string): string {
+  return prompt.toLowerCase().replace(/[^a-z0-9\s-]/g, " ");
+}
+
+function words(prompt: string): string[] {
+  return normalise(prompt)
+    .split(/\s+/)
+    .filter((word) => word.length > 2 && !STOPWORDS.has(word));
+}
+
+interface SynonymMatch {
+  /** Item name to the phrase that selected it. */
+  hits: Map<string, string>;
+  /**
+   * Words the table has already spoken for.
+   *
+   * Excluded from generic term matching afterwards. The table exists to say
+   * that "plan" means pricing or billing; letting the generic matcher also
+   * score every item with "plan" in its name puts `ai-agent-plan` on a billing
+   * page and re-introduces exactly the ambiguity the table resolves.
+   */
+  consumed: Set<string>;
+}
+
+function synonymHits(prompt: string): SynonymMatch {
+  const text = normalise(prompt);
+  const hits = new Map<string, string>();
+  const consumed = new Set<string>();
+
+  for (const [phrase, names] of Object.entries(SYNONYMS)) {
+    // Word-boundary matched, so "keyboard" does not trigger "key".
+    const pattern = new RegExp(`(^|\\s)${phrase.replace(/\s+/g, "\\s+")}(\\s|$)`);
+    if (!pattern.test(text)) continue;
+
+    for (const word of phrase.split(/\s+/)) consumed.add(word);
+    for (const name of names) {
+      if (!hits.has(name)) hits.set(name, phrase);
+    }
+  }
+
+  return { hits, consumed };
+}
+
+/** Below this a match is coincidence rather than intent. */
+const MINIMUM_SCORE = 20;
+
+interface Scored {
+  entry: RegistryIndexEntry;
+  /** What the prompt actually matched. Decides whether it qualifies at all. */
+  score: number;
+  /** Score plus the block preference. Decides order only. */
+  rank: number;
+  because: string;
+}
+
+function scoreEntry(
+  entry: RegistryIndexEntry,
+  terms: string[],
+  synonyms: Map<string, string>,
+): Scored | undefined {
+  const name = entry.name.toLowerCase();
+  const title = entry.title.toLowerCase();
+  const description = entry.description.toLowerCase();
+
+  let score = 0;
+  const reasons: string[] = [];
+
+  const synonym = synonyms.get(entry.name);
+  if (synonym) {
+    score += 60;
+    reasons.push(`"${synonym}"`);
+  }
+
+  for (const term of terms) {
+    if (name === term) {
+      score += 50;
+      reasons.push(`named "${term}"`);
+    } else if (name.split("-").includes(term)) {
+      score += 30;
+      reasons.push(`"${term}" in its name`);
+    } else if (title.includes(term)) {
+      score += 20;
+      reasons.push(`"${term}" in its title`);
+    } else if (entry.category === term) {
+      score += 12;
+      reasons.push(`the ${term} category`);
+    } else if (description.includes(term)) {
+      score += 8;
+      reasons.push(`"${term}" in its description`);
+    }
+  }
+
+  if (score === 0) return undefined;
+
+  // A block covers more of an intent than a component does, and installing one
+  // brings the components anyway — so where both match, the block is the better
+  // answer rather than merely an equal one.
+  //
+  // Kept out of `score` on purpose. Added there it would lift a block over the
+  // qualifying floor on a description-only brush, which is how `ai-dashboard`
+  // ended up recommended for an agent console because its prose contains the
+  // word "run". A preference should order real matches, not manufacture one.
+  const rank = score + (entry.type === "registry:block" ? 25 : 0);
+
+  return { entry, score, rank, because: [...new Set(reasons)].slice(0, 3).join(", ") };
+}
+
+export interface PlanOptions {
+  /** How many components to suggest beyond the blocks. */
+  maxComponents?: number;
+  /** How many blocks to suggest. */
+  maxBlocks?: number;
+}
+
+export function planUi(
+  prompt: string,
+  index: RegistryIndex,
+  options: PlanOptions = {},
+): UiPlan {
+  const { maxBlocks = 3, maxComponents = 6 } = options;
+
+  const { hits: synonyms, consumed } = synonymHits(prompt);
+  const terms = words(prompt).filter((term) => !consumed.has(term));
+
+  const scored = index.items
+    .filter((entry) => entry.type === "registry:ui" || entry.type === "registry:block")
+    .map((entry) => scoreEntry(entry, terms, synonyms))
+    .filter((candidate): candidate is Scored => candidate !== undefined)
+    // A description-only brush (8) or a bare category hit (12) is not enough on
+    // its own. Suggesting six components because the prompt shares a common
+    // word with their prose makes the plan look like more work than it is, and
+    // buries the ones that actually matched.
+    .filter((candidate) => candidate.score >= MINIMUM_SCORE)
+    .sort((a, b) => b.rank - a.rank || a.entry.name.localeCompare(b.entry.name));
+
+  const blocks = scored
+    .filter((candidate) => candidate.entry.type === "registry:block")
+    .slice(0, maxBlocks);
+
+  // Anything a chosen block already installs is not a separate suggestion:
+  // listing Button beside a Dashboard that brings it is noise that makes the
+  // plan look longer than the work.
+  const covered = new Set(
+    blocks.flatMap((candidate) => [
+      candidate.entry.name,
+      ...candidate.entry.registryDependencies,
+    ]),
+  );
+
+  const components = scored
+    .filter(
+      (candidate) =>
+        candidate.entry.type === "registry:ui" && !covered.has(candidate.entry.name),
+    )
+    .slice(0, maxComponents);
+
+  const toEntry = (candidate: Scored): PlanEntry => ({
+    entry: candidate.entry,
+    because: candidate.because,
+  });
+
+  return {
+    prompt,
+    blocks: blocks.map(toEntry),
+    components: components.map(toEntry),
+    install: [...blocks, ...components].map((candidate) => candidate.entry.name),
+    empty: blocks.length === 0 && components.length === 0,
+  };
+}
+
+/** PascalCase export name for a registry name, e.g. "ai-tool" -> "AiTool". */
+function tag(name: string): string {
+  return name
+    .split("-")
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+/** Blocks export a `…Block` component; components export their own name. */
+function componentName(entry: RegistryIndexEntry): string {
+  const base = tag(entry.name);
+  return entry.type === "registry:block" ? `${base}Block` : base;
+}
+
+export interface RenderOptions {
+  /** Where components are imported from in the target project. */
+  importFrom?: string;
+  /**
+   * Where blocks are imported from.
+   *
+   * Separate because blocks are not exported from the component package at
+   * all — they are only ever installed as source — so deriving their path from
+   * a package specifier produces an import that does not exist. Derived from
+   * `importFrom` when it is a project alias, and otherwise the conventional
+   * install location.
+   */
+  blocksImportFrom?: string;
+  cliPackage?: string;
+  docsUrl?: string;
+}
+
+/**
+ * Where an installed block lives.
+ *
+ * A project alias like `@/components/ui` has a sibling `@/components/blocks`. A
+ * bare package specifier has no block path at all, so the conventional install
+ * location is used instead of inventing one under the package.
+ */
+export function blocksPathFor(importFrom: string): string {
+  if (importFrom.endsWith("/ui")) return `${importFrom.slice(0, -3)}/blocks`;
+  if (importFrom.startsWith("@/") || importFrom.startsWith("~/")) {
+    return `${importFrom}/blocks`;
+  }
+  return "@/components/blocks";
+}
+
+/**
+ * The plan as a starting file.
+ *
+ * Imports and composition only. Every element carries the page its props are
+ * documented on, because the registry does not publish prop shapes and a
+ * plausible invented prop is worse than an obvious gap — one is a TODO, the
+ * other is a bug wearing the costume of working code.
+ */
+export function renderPlan(plan: UiPlan, options: RenderOptions = {}): string {
+  const {
+    importFrom = "@/components/ui",
+    docsUrl = "https://dowel-eight.vercel.app",
+    blocksImportFrom = blocksPathFor(importFrom),
+  } = options;
+
+  if (plan.empty) {
+    return `// Nothing in the registry matched "${plan.prompt}".\n`;
+  }
+
+  const chosen = [...plan.blocks, ...plan.components];
+
+  const imports = chosen
+    .map((item) => {
+      const from =
+        item.entry.type === "registry:block"
+          ? `${blocksImportFrom}/${item.entry.name}`
+          : `${importFrom}/${item.entry.name}`;
+      return `import { ${componentName(item.entry)} } from "${from}";`;
+    })
+    .sort();
+
+  const body = chosen
+    .map((item) => {
+      const name = componentName(item.entry);
+      return [
+        `      {/* ${item.entry.title} — props: ${docsUrl}/docs/${
+          item.entry.type === "registry:block" ? "blocks" : "components"
+        }/${item.entry.name} */}`,
+        `      <${name} />`,
+      ].join("\n");
+    })
+    .join("\n\n");
+
+  return `${imports.join("\n")}
+
+export default function Page() {
+  return (
+    <div className="flex flex-col gap-6">
+${body}
+    </div>
+  );
+}
+`;
+}
+
+/**
+ * The plan as a brief for a coding agent.
+ *
+ * The most useful thing this can produce. The agent has the project, the
+ * editor and the ability to write the props; what it lacks is the knowledge
+ * that these components exist and that it must not invent others. That is
+ * exactly what a grounded plan supplies.
+ */
+export function renderBrief(plan: UiPlan, options: RenderOptions = {}): string {
+  const {
+    cliPackage = "@dowel-ui/cli",
+    docsUrl = "https://dowel-eight.vercel.app",
+    importFrom = "@/components/ui",
+  } = options;
+
+  if (plan.empty) {
+    return `Nothing in the registry matched "${plan.prompt}". Search the catalogue at ${docsUrl}/docs/components before building anything by hand.`;
+  }
+
+  const lines = [
+    `Build: ${plan.prompt}`,
+    "",
+    "Use these, which are already in the registry. Do not write your own versions,",
+    "and do not use any component not listed here without checking the catalogue first.",
+    "",
+  ];
+
+  if (plan.blocks.length > 0) {
+    lines.push("Blocks (whole sections — each installs its own components):");
+    for (const item of plan.blocks) {
+      lines.push(`- ${item.entry.name} — ${item.entry.description}`);
+    }
+    lines.push("");
+  }
+
+  if (plan.components.length > 0) {
+    lines.push("Components:");
+    for (const item of plan.components) {
+      lines.push(`- ${item.entry.name} — ${item.entry.description}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(
+    "Install first:",
+    "",
+    `    npx ${cliPackage} add ${plan.install.join(" ")}`,
+    "",
+    `Import from \`${importFrom}\`. Each component's props are on its page under`,
+    `${docsUrl}/docs/components — read the page rather than guessing a prop name.`,
+    "",
+    "Style with semantic tokens only (bg-background, text-muted-foreground). Never raw",
+    "hex, never Tailwind's own palette — those do not follow the theme.",
+  );
+
+  return lines.join("\n");
+}

package/src/index.ts

@@ -1,12 +1,53 @@
+export {
+  blocksPathFor,
+  planUi,
+  renderBrief,
+  renderPlan,
+  type PlanEntry,
+  type PlanOptions,
+  type RenderOptions,
+  type UiPlan,
+} from "./generate";
+
+export {
+  assertResolvable,
+  buildCustomRegistry,
+  defineRegistryConfig,
+  itemGroupSchema,
+  itemSourceSchema,
+  registryConfigSchema,
+  type BuildResult,
+  type ItemGroup,
+  type ItemSource,
+  type RegistryConfig,
+} from "./custom";
+
+export {
+  AGENTS_MARKER_END,
+  AGENTS_MARKER_START,
+  agentsSection,
+  aiDoc,
+  componentsDoc,
+  conventionsDoc,
+  cursorRule,
+  llmsFullTxt,
+  llmsTxt,
+  skillDoc,
+  themesDoc,
+  upsertAgentsSection,
+  type AgentDocsContext,
+} from "./agent-docs";
 export { hashContent } from "./hash";
 export {
   REGISTRY_VERSION,
+  registryAccessSchema,
   registryFileSchema,
   registryFileTypeSchema,
   registryIndexEntrySchema,
   registryIndexSchema,
   registryItemSchema,
   registryItemTypeSchema,
+  type RegistryAccess,
   type RegistryFile,
   type RegistryFileType,
   type RegistryIndex,

package/src/schema.ts

@@ -38,6 +38,18 @@ export const registryItemTypeSchema = z.enum([
 
 export type RegistryItemType = z.infer<typeof registryItemTypeSchema>;
 
+/**
+ * Whether an item's source is public.
+ *
+ * `free` is the default and stays the default: an item that has ever been
+ * installable without a licence must never quietly become one that is not.
+ * Existing registries carry no `access` field at all, which parses as `free` —
+ * so an older registry read by a newer CLI behaves exactly as it did.
+ */
+export const registryAccessSchema = z.enum(["free", "pro"]).default("free");
+
+export type RegistryAccess = z.infer<typeof registryAccessSchema>;
+
 export const registryFileSchema = z.object({
   /**
    * Logical path within the registry, e.g. `ui/button.tsx`, `lib/utils.ts`.
@@ -76,10 +88,20 @@ export const registryItemSchema = z.object({
   registryDependencies: z.array(z.string()),
   files: z.array(registryFileSchema).min(1),
   a11y: z.string().optional(),
+  access: registryAccessSchema,
 });
 
 export type RegistryItem = z.infer<typeof registryItemSchema>;
 
+/**
+ * The index entry.
+ *
+ * Carries `access` so a licensed item is *listed* — with its title, what it
+ * depends on and how many files it has — while its source is not. Hiding paid
+ * items entirely would mean nobody could discover them; including their source
+ * would mean nobody needed to buy them. The index is the catalogue; the item
+ * body is the goods.
+ */
 export const registryIndexEntrySchema = registryItemSchema
   .pick({
     name: true,
@@ -90,6 +112,7 @@ export const registryIndexEntrySchema = registryItemSchema
     status: true,
     dependencies: true,
     registryDependencies: true,
+    access: true,
   })
   .extend({ fileCount: z.number().int().positive() });
 

package/dist/schema-ByqIpT47.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-ByqIpT47.js","names":[],"sources":["../src/hash.ts","../src/schema.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\n\n/**\n * Content hash used to detect local edits to an installed file.\n *\n * Line endings are normalised before hashing so a Windows checkout does not\n * read as \"every file modified\", which would make `update` useless there.\n */\nexport function hashContent(content: string): string {\n  const normalised = content.replace(/\\r\\n/g, \"\\n\");\n  return `sha256:${createHash(\"sha256\").update(normalised, \"utf8\").digest(\"hex\")}`;\n}\n","import { z } from \"zod\";\n\n/**\n * The public registry contract.\n *\n * This is the boundary between the library and every consumer's project, so it\n * is validated on both sides: the build refuses to emit anything that does not\n * satisfy it, and the CLI refuses to install anything that does not parse. A\n * registry that serves malformed data breaks builds in someone else's\n * repository, where it is hardest to diagnose.\n */\n\n/** Bumped only for a breaking change to the shape below. */\nexport const REGISTRY_VERSION = 1;\n\nexport const registryFileTypeSchema = z.enum([\n  /** A component. Installed under the `ui` alias. */\n  \"registry:ui\",\n  /** A shared utility. Installed under the `lib` alias. */\n  \"registry:lib\",\n  /** A hook. Installed under the `hooks` alias. */\n  \"registry:hook\",\n  /** A whole page section. Installed under the `blocks` alias. */\n  \"registry:block\",\n  /** CSS appended to the project stylesheet rather than written as a file. */\n  \"registry:style\",\n]);\n\nexport type RegistryFileType = z.infer<typeof registryFileTypeSchema>;\n\nexport const registryItemTypeSchema = z.enum([\n  \"registry:ui\",\n  \"registry:lib\",\n  \"registry:hook\",\n  \"registry:theme\",\n  \"registry:block\",\n]);\n\nexport type RegistryItemType = z.infer<typeof registryItemTypeSchema>;\n\nexport const registryFileSchema = z.object({\n  /**\n   * Logical path within the registry, e.g. `ui/button.tsx`, `lib/utils.ts`.\n   *\n   * The leading segment selects which of the consumer's aliases the file is\n   * written under. The registry deliberately does not know the destination —\n   * that depends on a project layout it has never seen.\n   */\n  path: z.string().min(1),\n  type: registryFileTypeSchema,\n  content: z.string(),\n  /**\n   * `sha256:<hex>` of `content` as published.\n   *\n   * Recorded at install time so `update` can tell an untouched file from one\n   * the user has edited. This cannot be added later: an install that did not\n   * record a hash leaves no way to know what it originally wrote.\n   */\n  hash: z.string().regex(/^sha256:[0-9a-f]{64}$/),\n});\n\nexport type RegistryFile = z.infer<typeof registryFileSchema>;\n\nexport const registryItemSchema = z.object({\n  $schema: z.string().optional(),\n  registryVersion: z.literal(REGISTRY_VERSION),\n  name: z.string().regex(/^[a-z][a-z0-9-]*$/),\n  type: registryItemTypeSchema,\n  title: z.string().min(1),\n  description: z.string().min(10),\n  category: z.string().min(1),\n  status: z.enum([\"stable\", \"beta\", \"experimental\"]),\n  /** npm packages to install alongside the files. */\n  dependencies: z.array(z.string()),\n  /** Other registry items to install first. */\n  registryDependencies: z.array(z.string()),\n  files: z.array(registryFileSchema).min(1),\n  a11y: z.string().optional(),\n});\n\nexport type RegistryItem = z.infer<typeof registryItemSchema>;\n\nexport const registryIndexEntrySchema = registryItemSchema\n  .pick({\n    name: true,\n    type: true,\n    title: true,\n    description: true,\n    category: true,\n    status: true,\n    dependencies: true,\n    registryDependencies: true,\n  })\n  .extend({ fileCount: z.number().int().positive() });\n\nexport type RegistryIndexEntry = z.infer<typeof registryIndexEntrySchema>;\n\nexport const registryIndexSchema = z.object({\n  $schema: z.string().optional(),\n  registryVersion: z.literal(REGISTRY_VERSION),\n  /** Version of the package the registry was generated from. */\n  generatedFrom: z.string().min(1),\n  items: z.array(registryIndexEntrySchema),\n});\n\nexport type RegistryIndex = z.infer<typeof registryIndexSchema>;\n"],"mappings":";;;;;;;;;AAQA,SAAgB,YAAY,SAAyB;CACnD,MAAM,aAAa,QAAQ,QAAQ,SAAS,IAAI;CAChD,OAAO,UAAU,WAAW,QAAQ,CAAC,CAAC,OAAO,YAAY,MAAM,CAAC,CAAC,OAAO,KAAK;AAC/E;;;;;;;;;;;;;ACEA,MAAa,mBAAmB;AAEhC,MAAa,yBAAyB,EAAE,KAAK;CAE3C;CAEA;CAEA;CAEA;CAEA;AACF,CAAC;AAID,MAAa,yBAAyB,EAAE,KAAK;CAC3C;CACA;CACA;CACA;CACA;AACF,CAAC;AAID,MAAa,qBAAqB,EAAE,OAAO;;;;;;;;CAQzC,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACtB,MAAM;CACN,SAAS,EAAE,OAAO;;;;;;;;CAQlB,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,uBAAuB;AAChD,CAAC;AAID,MAAa,qBAAqB,EAAE,OAAO;CACzC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,iBAAiB,EAAE,QAAA,CAAwB;CAC3C,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,mBAAmB;CAC1C,MAAM;CACN,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE;CAC9B,UAAU,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC1B,QAAQ,EAAE,KAAK;EAAC;EAAU;EAAQ;CAAc,CAAC;;CAEjD,cAAc,EAAE,MAAM,EAAE,OAAO,CAAC;;CAEhC,sBAAsB,EAAE,MAAM,EAAE,OAAO,CAAC;CACxC,OAAO,EAAE,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC;CACxC,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS;AAC5B,CAAC;AAID,MAAa,2BAA2B,mBACrC,KAAK;CACJ,MAAM;CACN,MAAM;CACN,OAAO;CACP,aAAa;CACb,UAAU;CACV,QAAQ;CACR,cAAc;CACd,sBAAsB;AACxB,CAAC,CAAC,CACD,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;AAIpD,MAAa,sBAAsB,EAAE,OAAO;CAC1C,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,iBAAiB,EAAE,QAAA,CAAwB;;CAE3C,eAAe,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC/B,OAAO,EAAE,MAAM,wBAAwB;AACzC,CAAC"}

package/dist/schema-Cc32v3R-.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-Cc32v3R-.d.ts","names":[],"sources":["../src/schema.ts"],"mappings":";;;;;;;;;;;;cAaa;cAEA,wBAAsB,EAAA;;;;;;;KAavB,mBAAmB,EAAE,aAAa;cAEjC,wBAAsB,EAAA;;;;;;;KAQvB,mBAAmB,EAAE,aAAa;cAEjC,oBAAkB,EAAA;;;;;;;;;;;GAmB7B,EAAA,KAAA;KAEU,eAAe,EAAE,aAAa;cAE7B,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe7B,EAAA,KAAA;KAEU,eAAe,EAAE,aAAa;cAE7B,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;GAWgB,EAAA,KAAA;KAEzC,qBAAqB,EAAE,aAAa;cAEnC,qBAAmB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAM9B,EAAA,KAAA;KAEU,gBAAgB,EAAE,aAAa"}