@bastani/atomic 0.5.34 → 0.6.0-0

package/.agents/skills/workflow-creator/references/workflow-inputs.md

@@ -1,272 +0,0 @@
-# Workflow Inputs
-
-Workflows collect structured data from the user at invocation time through
-a single uniform API: `ctx.inputs` (and `s.inputs` inside stage
-callbacks). This reference covers how the inputs pipe works, how to
-declare input schemas, and how values reach the workflow from the CLI
-and the interactive picker.
-
-## The inputs pipe
-
-Every workflow run receives a typed inputs object. When the workflow
-declares an `inputs` schema, only the declared field names are valid
-keys — accessing undeclared fields is a compile-time error. The
-runtime populates it from whichever invocation surface the user chose:
-
-| Surface | How values are supplied | How they land in `ctx.inputs` |
-|---|---|---|
-| **Named run, positional** — `atomic workflow -n hello -a claude "fix the bug"` | A single positional prompt string (the workflow must declare a `prompt` input) | `{ prompt: "fix the bug" }` |
-| **Named run, structured** — `atomic workflow -n gen-spec -a claude --research_doc=notes.md --focus=standard` | One `--<field>=<value>` flag per declared input | `{ research_doc: "notes.md", focus: "standard" }` |
-| **Interactive picker** — `atomic workflow -a claude` | The user fills in a form rendered from the declared schema | Whatever the user typed, keyed by field name |
-
-Workflow code is the same either way — it always reads
-`ctx.inputs.<name>`. The invocation surface is a CLI concern, not a
-workflow concern.
-
-## Reading inputs
-
-Workflows that accept a user prompt should declare it explicitly as an
-input. Destructure it once at the top of `.run()` so every stage can
-close over a bare string:
-
-```ts
-defineWorkflow({
-    name: "answer",
-    description: "Single-turn answer",
-    inputs: [
-      { name: "prompt", type: "text", required: true, description: "question to answer" },
-    ],
-  })
-  .for<"claude">()
-  .run(async (ctx) => {
-    const prompt = ctx.inputs.prompt ?? "";
-
-    await ctx.stage({ name: "answer" }, {}, {}, async (s) => {
-      await s.session.query(prompt);
-      s.save(s.sessionId);
-    });
-  })
-  .compile();
-```
-
-For structured workflows, read each declared field by name. Pull them
-out of `ctx.inputs` once for readability and so downstream stages can
-close over locals:
-
-```ts
-defineWorkflow({
-    name: "gen-spec",
-    description: "Convert a research doc into a detailed execution spec",
-    inputs: [
-      { name: "research_doc", type: "string", required: true },
-      {
-        name: "focus",
-        type: "enum",
-        required: true,
-        values: ["minimal", "standard", "exhaustive"],
-        default: "standard",
-      },
-      { name: "notes", type: "text" },
-    ],
-  })
-  .for<"claude">()
-  .run(async (ctx) => {
-    const { research_doc, focus } = ctx.inputs;
-    const notes = ctx.inputs.notes ?? "";
-
-    await ctx.stage({ name: "write-spec" }, {}, {}, async (s) => {
-      await s.session.query(
-        `Read ${research_doc} and produce a ${focus} spec.` +
-          (notes ? `\n\nExtra guidance:\n${notes}` : ""),
-      );
-      s.save(s.sessionId);
-    });
-  })
-  .compile();
-```
-
-The nullish coalescing on `notes` handles the optional field case —
-declared-but-unset inputs resolve to `undefined` unless they have a
-`default`.
-
-**Style convention.** Inside a stage callback, both `s.inputs.<name>` and
-`ctx.inputs.<name>` resolve to the same value. Either of these patterns
-works:
-
-- **Destructure once at the top of `.run()`** so each stage closes over a
-  bare local. Best when many stages reference the same input.
-- **Inline access** with `(s.inputs.<name> ?? "")` at each call site. Best
-  for short workflows or when each stage uses a different field.
-
-Pick whichever reads cleaner for your workflow. Examples in other reference
-files use the inline form for brevity in focused snippets.
-
-## Declaring an input schema
-
-Pass an `inputs` array to `defineWorkflow({ ... })`. Each entry is a
-`WorkflowInput`:
-
-```ts
-interface WorkflowInput {
-  /** Field name — becomes the CLI flag (`--<name>`) and form label. */
-  name: string;
-  /** Input kind: string | text | enum */
-  type: "string" | "text" | "enum";
-  /** Whether the field must be non-empty before the workflow can run. */
-  required?: boolean;
-  /** Short description shown as the field caption. */
-  description?: string;
-  /** Placeholder shown when the field is empty. */
-  placeholder?: string;
-  /** Default value — enums use this to pick their initial value. */
-  default?: string;
-  /** Allowed values — required when `type` is `"enum"`. */
-  values?: readonly string[];
-}
-```
-
-### Picking a field type
-
-| Type | Use when | Picker renders as | Example |
-|---|---|---|---|
-| `string` | Short single-line values — identifiers, file paths, branch names | Single-row text input | `research_doc: "notes.md"` |
-| `text` | Longer free-form prose — specs, prompts, extra context | Multi-row text area | `spec: "Build a..."` |
-| `enum` | A fixed set of allowed values | Radio-button row | `focus: "standard" \| "minimal" \| "exhaustive"` |
-
-Rule of thumb: use `enum` whenever there's a closed set of options — it
-gives users discoverable choices instead of making them remember magic
-strings, and the CLI will reject invalid values at parse time.
-
-### Validation enforced by the runtime
-
-The `defineWorkflow` builder validates the schema at compile time and
-rejects authoring mistakes immediately — you won't discover them in
-production:
-
-- **Input names must be valid CLI flag tails** — start with a letter,
-  then letters/digits/underscores/dashes. `1bad` is rejected because
-  `--1bad` isn't a parseable flag.
-- **Enum inputs must declare `values`** — an enum with no choices is
-  always invalid.
-- **Enum `default` must be in `values`** — prevents drift between the
-  default and the allowed set.
-- **No duplicate names** — two inputs with the same `name` shadow each
-  other and are rejected.
-
-At invocation time, the CLI does a second pass to catch runtime errors
-before spinning up any tmux session:
-
-- **Required fields must be non-empty** (whitespace-only strings are
-  treated as empty). Missing required fields produce a clear
-  `Missing required input --<name>` error and exit non-zero.
-- **Enum values must be in the allowed list.** `--focus=bogus` produces
-  `Invalid value for --focus: "bogus". Expected one of: minimal, standard, exhaustive.`
-- **Unknown flags are rejected.** A `--random_flag=value` that isn't in
-  the schema produces `Unknown input --random_flag` with the valid
-  flag list appended.
-
-This validation runs before any workflow code, so a malformed
-invocation can never reach your `.run()` callback in a half-filled
-state.
-
-## Declaring a prompt input
-
-Workflows that accept a user prompt should declare it explicitly in their
-`inputs` array rather than relying on an implicit key:
-
-```ts
-inputs: [
-  { name: "prompt", type: "text", required: true, description: "task to perform" },
-]
-```
-
-This gives the same CLI ergonomics — `atomic workflow -n hello -a claude "fix the bug"` still works — while providing compile-time safety. Accessing `ctx.inputs.prompt` without declaring it is a type error.
-
-For workflows that need both a free-form prompt AND structured parameters,
-declare all fields in the schema:
-
-```ts
-inputs: [
-  { name: "prompt", type: "text", required: true, description: "what to build" },
-  { name: "focus", type: "enum", required: true, values: ["minimal", "standard", "exhaustive"], default: "standard" },
-  { name: "notes", type: "text", description: "extra context" },
-]
-```
-
-## The interactive picker
-
-`atomic workflow -a <agent>` (no `-n`) launches the interactive
-picker. The picker:
-
-1. Discovers all workflows compatible with `<agent>` across local,
-   global, and builtin sources.
-2. Loads each workflow's metadata (description + declared inputs).
-3. Shows a Telescope-style fuzzy list. The user types to filter,
-   arrows to navigate, ↵ to lock in a selection.
-4. Renders the selected workflow's form. The picker renders one field
-   per declared input with type-specific rendering.
-5. Validates required fields on ⌃s. If any are empty, focus jumps to
-   the first invalid field and the run button stays disabled.
-6. Confirms with a y/n modal, then tears down the picker and hands
-   off to the workflow executor — same live-run surface users see
-   when they invoke the workflow with `-n` directly.
-
-The picker is the preferred discovery path for users who don't
-remember flag names. Structured workflows benefit the most from it
-because the form teaches the schema as the user fills it in.
-
-## Builtin protection
-
-Builtin names (`ralph`, `deep-research-codebase`) are reserved — pick
-distinct names for your workflows. Full precedence + shadowing rules
-live in `discovery-and-verification.md`.
-
-## Invocation details
-
-See SKILL.md §"Invocation surfaces" for the table of every top-level
-command. This section only covers the flag-parsing nuances specific to
-structured inputs.
-
-Both `--flag=value` and `--flag value` forms are accepted. Short flags
-(`-x value`) are NOT parsed as structured inputs — only long-form
-`--<name>` flags resolve against the schema.
-
-The `-d` / `--detach` flag composes with any named shape (positional
-prompt, structured flags) and is independent of the inputs schema.
-
-```bash
-# Structured, both flag forms work identically
-atomic workflow -n gen-spec -a claude --focus=standard --research_doc=notes.md
-atomic workflow -n gen-spec -a claude --focus standard --research_doc notes.md
-```
-
-## Pitfalls
-
-### Declare every field you access
-
-With typed inputs, accessing `ctx.inputs.foo` when `foo` is not declared
-in the workflow's `inputs` array is a compile-time error. If your workflow
-needs a prompt field, declare it:
-
-```ts
-inputs: [
-  { name: "prompt", type: "text", required: true, description: "task prompt" },
-]
-```
-
-The CLI rejects positional prompt strings for workflows that don't declare
-a `prompt` input.
-
-### Don't rename inputs across workflow versions
-
-Declared input names are part of the workflow's public API — they map
-directly to `--<name>` flags and field identifiers in the picker.
-Renaming a field is a breaking change for any script that invokes the
-workflow. If you need to rename, add the new name alongside the old,
-migrate callers, then remove the old name in a later change.
-
-### Don't put secrets in `default`
-
-Defaults are visible in the picker and printed in CLI errors. They're
-fine for values like `"standard"` but not for API keys or auth tokens.
-Read those from environment variables inside the workflow instead.

package/dist/sdk/runtime/discovery.d.ts

@@ -1,132 +0,0 @@
-/**
- * Workflow discovery — finds workflow definitions from disk.
- *
- * Workflows are discovered from:
- *   1. src/sdk/workflows/builtin/<name>/<agent>/index.ts (SDK-shipped builtins)
- *   2. .atomic/workflows/<name>/<agent>/index.ts (project-local)
- *   3. ~/.atomic/workflows/<name>/<agent>/index.ts (global)
- *
- * All three sources use the same scanning function (`discoverFromBaseDir`)
- * so registration is uniform. Builtin names are reserved — project-local
- * and global workflows with the same name are dropped during merge.
- */
-import type { AgentType, WorkflowInput } from "../types.ts";
-export interface DiscoveredWorkflow {
-    name: string;
-    agent: AgentType;
-    path: string;
-    source: "local" | "global" | "builtin";
-}
-export declare const AGENTS: AgentType[];
-/**
- * Default `.gitignore` content for a workflows directory.
- * Auto-generated during install; regenerated by discovery if missing.
- */
-export declare const WORKFLOWS_GITIGNORE: string;
-/**
- * Discover all available workflows from built-in, global, and local sources.
- * Optionally filter by agent.
- *
- * **Merge precedence:** `builtin > local > global`.
- *
- * Builtin names are **strictly reserved** — a user-defined local or
- * global workflow whose name matches any built-in workflow is dropped
- * entirely from discovery. It will not be registered, returned from
- * `findWorkflow`, appear in the interactive picker, or show up in
- * `atomic workflow -l`. This protects SDK-shipped workflows (e.g.
- * `ralph`) from being silently overridden or even visibly "competing
- * with" a user's own definition, which would otherwise be confusing
- * when someone tries to run the canonical version.
- *
- * Reservation is by **name only**, across all agents: if a builtin
- * defines `ralph` for any agent, a local `ralph` for any other agent is
- * also dropped. Local still overrides global for every non-builtin
- * name, so project-scoped customisation of user-scoped workflows
- * continues to work.
- *
- * By default, the result is **merged by precedence** — if a workflow is
- * defined in both local and global sources, only the higher-precedence
- * entry is returned. This is the right shape for `findWorkflow`, which
- * needs the single resolved entry per (name, agent) pair.
- *
- * Pass `{ merge: false }` to get the **unmerged** result — local and
- * global contribute their entries independently, so `--list` can show
- * both a local and a global copy of the same workflow when they coexist
- * on disk. (Builtin reservation still applies in both modes.)
- */
-export declare function discoverWorkflows(projectRoot?: string, agentFilter?: AgentType, options?: {
-    merge?: boolean;
-}): Promise<DiscoveredWorkflow[]>;
-/**
- * Find a specific workflow by name and agent.
- */
-export declare function findWorkflow(name: string, agent: AgentType, projectRoot?: string): Promise<DiscoveredWorkflow | null>;
-/**
- * Load status for a {@link WorkflowWithMetadata} entry.
- *
- * - `ok`            — the workflow compiled cleanly and is ready to run.
- * - `incompatible`  — the workflow declared a `minSDKVersion` newer
- *                     than the bundled CLI. The CLI renders it with an
- *                     "update required" badge so users see the mismatch
- *                     rather than a silent disappearance.
- * - `error`         — any other load failure (syntax error, missing
- *                     `.compile()`, invalid default export, etc.).
- *                     Rendered with a "failed to load" badge plus the
- *                     underlying message.
- */
-export type WorkflowMetadataStatus = {
-    kind: "ok";
-} | {
-    kind: "incompatible";
-    requiredVersion: string;
-    currentVersion: string;
-    message: string;
-} | {
-    kind: "error";
-    stage: "resolve" | "validate" | "load";
-    message: string;
-};
-/**
- * A discovered workflow enriched with the metadata the picker needs to
- * render it: the human description, the declared input schema, and the
- * load status.
- *
- * Populated by {@link loadWorkflowsMetadata}, which runs each discovered
- * workflow through {@link WorkflowLoader.loadWorkflow} and extracts the
- * display-relevant fields — the full compiled definition is discarded
- * after extraction so re-imports during execution are cheap.
- *
- * Broken entries still materialise with empty `description` / `inputs`
- * and a non-`ok` {@link status}, so the picker can render them as
- * visible "update required" / "failed to load" rows instead of
- * silently omitting them (the previous behaviour, which made user and
- * global workflows vanish whenever the base SDK shape drifted between
- * releases).
- */
-export interface WorkflowWithMetadata extends DiscoveredWorkflow {
-    /** Workflow description, empty string when none was declared or the workflow failed to load. */
-    description: string;
-    /** Picker-ready input schema; empty for free-form or failed-to-load workflows. */
-    inputs: readonly WorkflowInput[];
-    /** Load outcome — non-`ok` entries are rendered as visible diagnostics in the picker/list. */
-    status: WorkflowMetadataStatus;
-}
-/**
- * Load metadata (description + picker-ready inputs + status) for a batch
- * of discovered workflows.
- *
- * **Failed workflows are kept in the returned list**, not dropped. Each
- * broken entry carries a {@link WorkflowMetadataStatus} explaining the
- * failure so the picker and `atomic workflow -l` can surface it as an
- * actionable diagnostic. This is the only way end users discover that a
- * workflow from an older SDK release has gone incompatible after an
- * `atomic` upgrade — silent filtering would leave them with a missing
- * entry and no breadcrumb.
- *
- * Callers that want to execute a workflow should still route through
- * {@link WorkflowLoader.loadWorkflow} — this function throws away the
- * compiled definition so re-running the loader on a confirmed pick is
- * unavoidable.
- */
-export declare function loadWorkflowsMetadata(discovered: DiscoveredWorkflow[]): Promise<WorkflowWithMetadata[]>;
-//# sourceMappingURL=discovery.d.ts.map

package/dist/sdk/runtime/discovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAI5D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;CACxC;AAUD,eAAO,MAAM,MAAM,EAAE,SAAS,EAAsC,CAAC;AAGrE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,QASpB,CAAC;AAkGb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,GAAE,MAAsB,EACnC,WAAW,CAAC,EAAE,SAAS,EACvB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAChC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAoD/B;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,EAChB,WAAW,GAAE,MAAsB,GAClC,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAGpC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEN;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,gGAAgG;IAChG,WAAW,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,8FAA8F;IAC9F,MAAM,EAAE,sBAAsB,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA2CjC"}

package/dist/sdk/runtime/executor-entry.d.ts

@@ -1,11 +0,0 @@
-/**
- * Orchestrator entry point — invoked inside a tmux pane by the launcher script.
- *
- * Separated from executor.ts to avoid the dual-module-identity problem:
- * Bun evaluates a file twice when it is both the entry point (`bun run`)
- * and reached through package.json `exports` self-referencing. Keeping
- * the side-effectful `--run` guard here ensures executor.ts stays a pure
- * library module that can be safely re-exported from the SDK barrel.
- */
-export {};
-//# sourceMappingURL=executor-entry.d.ts.map

package/dist/sdk/runtime/executor-entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor-entry.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/executor-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/sdk/runtime/loader.d.ts

@@ -1,70 +0,0 @@
-/**
- * Workflow Loader — multi-stage pipeline for resolving and loading workflows.
- *
- * Pipeline: Discover → Resolve → Validate → Load
- *
- * Each stage returns a typed discriminated result so callers get structured
- * error information without try/catch guesswork.
- *
- * Discovery (finding workflow files on disk) remains in `discovery.ts`.
- * This module handles everything after a workflow is discovered.
- */
-import type { WorkflowDefinition } from "../types.ts";
-import type { DiscoveredWorkflow } from "./discovery.ts";
-export declare namespace WorkflowLoader {
-    /** Successful pipeline result. */
-    type Ok<T> = {
-        ok: true;
-        value: T;
-    };
-    /** Failed pipeline result with stage and error context. */
-    type StageError<S extends string> = {
-        ok: false;
-        stage: S;
-        error: unknown;
-        message: string;
-    };
-    type StageResult<T, S extends string> = Ok<T> | StageError<S>;
-    /** Input to the pipeline — a discovered workflow from disk. */
-    type Plan = DiscoveredWorkflow;
-    /** Output of the resolve stage. */
-    type Resolved = Plan;
-    /** Source validation warning — alias of the canonical type from types.ts. */
-    type ValidationWarning = import("../types.ts").ValidationWarning;
-    /** Output of the validate stage. */
-    type Validated = Resolved & {
-        warnings: ValidationWarning[];
-    };
-    /** Output of the load stage — the final result. */
-    type Loaded = Validated & {
-        definition: WorkflowDefinition;
-    };
-    interface Report {
-        /** Called when a stage begins. */
-        start?: (stage: "resolve" | "validate" | "load") => void;
-        /** Called when source validation produces warnings. */
-        warn?: (warnings: ValidationWarning[]) => void;
-        /** Called when a stage fails. */
-        error?: (stage: "resolve" | "validate" | "load", error: unknown, message: string) => void;
-    }
-    /** Verify the workflow file exists. */
-    function resolve(plan: Plan): Promise<StageResult<Resolved, "resolve">>;
-    /**
-     * Read the workflow source and run agent-specific validation checks.
-     * Validation warnings are non-fatal — the pipeline continues.
-     */
-    function validate(resolved: Resolved): Promise<StageResult<Validated, "validate">>;
-    /**
-     * Import the workflow module and extract the WorkflowDefinition.
-     * Checks for common authoring mistakes (missing `.compile()`, wrong export).
-     */
-    function load(validated: Validated): Promise<StageResult<Loaded, "load">>;
-    /**
-     * Run the full pipeline: resolve → validate → load.
-     *
-     * Returns a structured result with the loaded WorkflowDefinition on success,
-     * or a stage-specific error on failure.
-     */
-    function loadWorkflow(plan: Plan, report?: Report): Promise<StageResult<Loaded, "resolve" | "validate" | "load">>;
-}
-//# sourceMappingURL=loader.d.ts.map

package/dist/sdk/runtime/loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAa,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAazD,yBAAiB,cAAc,CAAC;IAK9B,kCAAkC;IAClC,KAAY,EAAE,CAAC,CAAC,IAAI;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC;IAE3C,2DAA2D;IAC3D,KAAY,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI;QACzC,EAAE,EAAE,KAAK,CAAC;QACV,KAAK,EAAE,CAAC,CAAC;QACT,KAAK,EAAE,OAAO,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,KAAY,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAMrE,+DAA+D;IAC/D,KAAY,IAAI,GAAG,kBAAkB,CAAC;IAEtC,mCAAmC;IACnC,KAAY,QAAQ,GAAG,IAAI,CAAC;IAE5B,6EAA6E;IAC7E,KAAY,iBAAiB,GAAG,OAAO,aAAa,EAAE,iBAAiB,CAAC;IAExE,oCAAoC;IACpC,KAAY,SAAS,GAAG,QAAQ,GAAG;QACjC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;KAC/B,CAAC;IAEF,mDAAmD;IACnD,KAAY,MAAM,GAAG,SAAS,GAAG;QAC/B,UAAU,EAAE,kBAAkB,CAAC;KAChC,CAAC;IAMF,UAAiB,MAAM;QACrB,kCAAkC;QAClC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,KAAK,IAAI,CAAC;QACzD,uDAAuD;QACvD,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;QAC/C,iCAAiC;QACjC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;KAC3F;IAMD,uCAAuC;IACvC,SAAsB,OAAO,CAC3B,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAoB3C;IAsBD;;;OAGG;IACH,SAAsB,QAAQ,CAC5B,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAiB7C;IAMD;;;OAGG;IACH,SAAsB,IAAI,CACxB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyDtC;IAMD;;;;;OAKG;IACH,SAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC,CA6B/D;CACF"}

package/dist/version.d.ts

@@ -1,2 +0,0 @@
-export declare const VERSION: string;
-//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,QAAsB,CAAC"}