@bitflow/core 0.5.4 → 0.7.0

package/dist/registry.d.ts

@@ -0,0 +1,118 @@
+import type { z } from "zod";
+import type { Diagnostic } from "./errors";
+import type { AttemptSnapshot, BitflowDocument, BitResult, Locale } from "./schema";
+/**
+ * A component supplied by a bit package.
+ *
+ * Deliberately not typed as a React component: `@bitflow/core` must stay
+ * importable from Node and must not depend on React. A React function
+ * component is structurally assignable to this, and the React layer narrows it
+ * back with a cast at the one place it renders.
+ */
+export type BitComponent<Props = any> = (props: Props) => unknown;
+/**
+ * What a bit is for, which is all the engine needs to know about it:
+ * - `start`/`end` bookend a run (`end` is terminal),
+ * - `task` accepts an answer and can be evaluated and scored,
+ * - `content` is shown and clicked past (titles, explanations, inputs).
+ */
+export declare const BIT_KINDS: readonly ["start", "content", "task", "end"];
+export type BitKind = (typeof BIT_KINDS)[number];
+export type EvaluateArgs<Data, Answer> = {
+    data: Data;
+    answer: Answer;
+};
+export type Evaluate<Data = any, Answer = any> = (args: EvaluateArgs<Data, Answer>) => BitResult | Promise<BitResult>;
+export type BitInfo = {
+    name: string;
+    description: string;
+};
+/**
+ * What every bit's learner-facing `Task` component is handed. Declared here,
+ * without React, so a bit package can type its component against the contract
+ * the flow and the standalone element both honour.
+ */
+export type BitTaskProps<Data = any, Answer = any> = {
+    data: Data;
+    answer?: Answer;
+    /** Present once evaluated; the view switches to showing the outcome. */
+    result?: BitResult;
+    /** Answered already, or being reviewed — render, but accept no input. */
+    readonly?: boolean;
+    locale: Locale;
+    onAnswerChange: (answer: Answer) => void;
+    /**
+     * The run so far, when there is one. Only `end` bits have any use for it —
+     * they summarise the attempt the learner just finished. A bit rendered
+     * standalone has no attempt, so anything reading this must cope without it.
+     */
+    attempt?: AttemptSnapshot;
+    /**
+     * The document being run, paired with `attempt`. An end bit needs it to turn
+     * the node ids in a snapshot back into tasks it can show. Absent for a bit
+     * rendered on its own.
+     */
+    flow?: BitflowDocument;
+};
+/** What every bit's author-facing `Form` component is handed. */
+export type BitFormProps<Data = any> = {
+    data: Data;
+    locale: Locale;
+    onChange: (data: Data) => void;
+    /**
+     * Validation problems for this node's data, with `path` relative to `data`,
+     * so the form can put each message next to the field that caused it.
+     */
+    errors?: Diagnostic[];
+};
+export type BitDefinition<Data = any, Answer = any> = {
+    /** Matches `BitNode.type`, e.g. `"task-choice"`. */
+    type: string;
+    kind: BitKind;
+    /** Validates `BitNode.data`. The envelope schema defers to this. */
+    schema: z.ZodType<Data>;
+    /** New-node data for the editor palette. Must satisfy `schema`. */
+    defaultData: () => Data;
+    /** Palette label and one-line help, per locale. */
+    info: (locale: Locale) => BitInfo;
+    /** Required for `kind: "task"`; how an answer becomes a result. */
+    evaluate?: Evaluate<Data, Answer>;
+    /**
+     * Whether the learner may move on from this step yet.
+     *
+     * For a step that is not graded but still has to be *done* — agreeing to
+     * take part, saying who you are. A task expresses the same thing by simply
+     * not being answered; a content bit had no way to say it at all, so a
+     * consent screen was a checkbox anyone could walk straight past.
+     *
+     * Absent means "always", which is every existing bit. Returning `false` must
+     * be accompanied by the bit rendering what is missing: the runtime only
+     * disables Next, it does not know what to say.
+     */
+    isComplete?: (args: EvaluateArgs<Data, Answer>) => boolean;
+    /** The learner-facing view. */
+    Task?: BitComponent;
+    /** Author-facing form for the bit's evaluation settings. */
+    Evaluation?: BitComponent;
+    /** Author-facing form for the bit's feedback settings. */
+    Feedback?: BitComponent;
+    /** Renders group statistics for this bit type. */
+    Statistic?: BitComponent;
+    /** Author-facing form for the bit's content. */
+    Form?: BitComponent;
+};
+/**
+ * Called by a bit package at module scope. Importing the package is the single
+ * action that makes its bit usable — inside a flow and as a standalone custom
+ * element alike.
+ *
+ * Re-registering the same type replaces the previous definition rather than
+ * throwing: two bundles on one page (say the editor and a standalone bit) may
+ * legitimately both load a bit, and the definitions are equivalent.
+ */
+export declare const registerBit: <Data, Answer>(definition: BitDefinition<Data, Answer>) => void;
+export declare const getBit: (type: string) => BitDefinition | undefined;
+export declare const hasBit: (type: string) => boolean;
+export declare const listBits: () => BitDefinition[];
+/** Test seam; not part of the public runtime story. */
+export declare const clearBits: () => void;

package/dist/schema.d.ts

@@ -0,0 +1,431 @@
+import { z } from "zod";
+/**
+ * Version of the `.bitflow` document format. Bumped only for changes a reader
+ * of an older document cannot absorb; additive optional fields do not bump it.
+ */
+export declare const FLOW_SCHEMA_VERSION = 1;
+export declare const LOCALES: readonly ["en", "de", "fr", "nl", "es", "it", "pt", "tr"];
+export declare const LocaleSchema: z.ZodEnum<{
+    de: "de";
+    en: "en";
+    es: "es";
+    fr: "fr";
+    it: "it";
+    nl: "nl";
+    pt: "pt";
+    tr: "tr";
+}>;
+export type Locale = z.infer<typeof LocaleSchema>;
+/**
+ * How a task turned out. Declared here rather than with the rest of the result
+ * types because conditions count outcomes, and the vocabulary has to exist
+ * before they can name one.
+ */
+export declare const BIT_RESULT_STATES: readonly ["correct", "wrong", 
+/**
+ * Not scorable: skipped, or a task whose evaluation is switched off. There is
+ * deliberately no "awaiting a teacher" state — bitflow grades in the browser
+ * and has no server, so nothing here could ever resolve one.
+ */
+"unknown"];
+export declare const BitResultStateSchema: z.ZodEnum<{
+    correct: "correct";
+    unknown: "unknown";
+    wrong: "wrong";
+}>;
+export type BitResultState = z.infer<typeof BitResultStateSchema>;
+/**
+ * Which tasks a count or a score is taken over.
+ *
+ * Absent means the whole attempt, which is what a whole-assessment threshold
+ * wants. A scope is what makes adaptive routing expressible: "did they pass
+ * *this section*", "of the *last three*, how many were right".
+ */
+export declare const ScopeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"section">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"nodes">;
+    nodeIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"last">;
+    count: z.ZodNumber;
+}, z.core.$strip>]>;
+export type Scope = z.infer<typeof ScopeSchema>;
+/** A value pulled out of the running attempt for a condition to compare. */
+export declare const ValueRefSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"answer">;
+    nodeId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"result">;
+    nodeId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"tries">;
+    nodeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"visits">;
+    nodeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"confidence">;
+    nodeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"timeSpent">;
+    nodeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"timeRemaining">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"score">;
+    scope: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"section">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"nodes">;
+        nodeIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"last">;
+        count: z.ZodNumber;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"scoreRatio">;
+    scope: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"section">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"nodes">;
+        nodeIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"last">;
+        count: z.ZodNumber;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"resultCount">;
+    state: z.ZodDefault<z.ZodEnum<{
+        correct: "correct";
+        unknown: "unknown";
+        wrong: "wrong";
+    }>>;
+    scope: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"section">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"nodes">;
+        nodeIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"last">;
+        count: z.ZodNumber;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>]>;
+export type ValueRef = z.infer<typeof ValueRefSchema>;
+export declare const COMPARE_OPS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "notIn", "isTrue"];
+export declare const CompareOpSchema: z.ZodEnum<{
+    eq: "eq";
+    gt: "gt";
+    gte: "gte";
+    in: "in";
+    isTrue: "isTrue";
+    lt: "lt";
+    lte: "lte";
+    ne: "ne";
+    notIn: "notIn";
+}>;
+export type CompareOp = z.infer<typeof CompareOpSchema>;
+declare const ComparableSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+export type Comparable = z.infer<typeof ComparableSchema>;
+export type Condition = {
+    type: "always";
+} | {
+    type: "compare";
+    left: ValueRef;
+    op: CompareOp;
+    right?: Comparable | Comparable[];
+} | {
+    type: "and";
+    conditions: Condition[];
+} | {
+    type: "or";
+    conditions: Condition[];
+} | {
+    type: "not";
+    condition: Condition;
+};
+export declare const ConditionSchema: z.ZodType<Condition>;
+export declare const PositionSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export type Position = z.infer<typeof PositionSchema>;
+/**
+ * A node in the flow. `type` names a bit ("task-choice", "title-simple", …)
+ * and `data` is owned by that bit's own schema — the envelope deliberately
+ * does not look inside it, so a document round-trips through a host that has
+ * not loaded every bit package.
+ */
+export declare const BitNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pool: z.ZodOptional<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BitNode = z.infer<typeof BitNodeSchema>;
+export declare const BitEdgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    sourceHandle: z.ZodOptional<z.ZodString>;
+    targetHandle: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+    resetTarget: z.ZodOptional<z.ZodEnum<{
+        answer: "answer";
+        result: "result";
+    }>>;
+}, z.core.$strip>;
+export type BitEdge = z.infer<typeof BitEdgeSchema>;
+export declare const ViewportSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    zoom: z.ZodNumber;
+}, z.core.$strip>;
+export type Viewport = z.infer<typeof ViewportSchema>;
+export declare const BitflowMetaSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodDefault<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    locale: z.ZodDefault<z.ZodEnum<{
+        de: "de";
+        en: "en";
+        es: "es";
+        fr: "fr";
+        it: "it";
+        nl: "nl";
+        pt: "pt";
+        tr: "tr";
+    }>>;
+    askConfidence: z.ZodDefault<z.ZodBoolean>;
+    askReasoning: z.ZodDefault<z.ZodBoolean>;
+    pools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodDefault<z.ZodString>;
+        draw: z.ZodNumber;
+        shuffle: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    sections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodDefault<z.ZodString>;
+        markdown: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    navigation: z.ZodDefault<z.ZodEnum<{
+        back: "back";
+        free: "free";
+        linear: "linear";
+    }>>;
+    allowSkip: z.ZodDefault<z.ZodBoolean>;
+    timeLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BitflowMeta = z.infer<typeof BitflowMetaSchema>;
+export declare const BitflowDocumentSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    meta: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodDefault<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        locale: z.ZodDefault<z.ZodEnum<{
+            de: "de";
+            en: "en";
+            es: "es";
+            fr: "fr";
+            it: "it";
+            nl: "nl";
+            pt: "pt";
+            tr: "tr";
+        }>>;
+        askConfidence: z.ZodDefault<z.ZodBoolean>;
+        askReasoning: z.ZodDefault<z.ZodBoolean>;
+        pools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodDefault<z.ZodString>;
+            draw: z.ZodNumber;
+            shuffle: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        sections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodDefault<z.ZodString>;
+            markdown: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        navigation: z.ZodDefault<z.ZodEnum<{
+            back: "back";
+            free: "free";
+            linear: "linear";
+        }>>;
+        allowSkip: z.ZodDefault<z.ZodBoolean>;
+        timeLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        pool: z.ZodOptional<z.ZodString>;
+        section: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        sourceHandle: z.ZodOptional<z.ZodString>;
+        targetHandle: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        resetTarget: z.ZodOptional<z.ZodEnum<{
+            answer: "answer";
+            result: "result";
+        }>>;
+    }, z.core.$strip>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        zoom: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BitflowDocument = z.infer<typeof BitflowDocumentSchema>;
+export declare const FeedbackMessageSchema: z.ZodObject<{
+    message: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        success: "success";
+        warning: "warning";
+    }>;
+}, z.core.$strip>;
+export type FeedbackMessage = z.infer<typeof FeedbackMessageSchema>;
+/**
+ * Evaluation settings every task bit offers, so a teacher meets the same three
+ * questions — how is it graded, may they retry, do they see feedback — in every
+ * task editor.
+ *
+ * `mode` decides what submitting does: `auto` grades it in the browser, `skip`
+ * shows it but never grades or scores it.
+ */
+export declare const EvaluationSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        skip: "skip";
+    }>>;
+    enableRetry: z.ZodDefault<z.ZodBoolean>;
+    showFeedback: z.ZodDefault<z.ZodBoolean>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    timeLimit: z.ZodOptional<z.ZodNumber>;
+    allowSkip: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Evaluation = z.infer<typeof EvaluationSchema>;
+/**
+ * The grading settings a task starts with.
+ *
+ * Bits use this rather than writing the object out, so adding a setting here
+ * reaches every bit at once instead of breaking each one's defaults.
+ */
+export declare const defaultEvaluation: () => Evaluation;
+export declare const BitResultSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        correct: "correct";
+        unknown: "unknown";
+        wrong: "wrong";
+    }>;
+    score: z.ZodOptional<z.ZodObject<{
+        earned: z.ZodNumber;
+        possible: z.ZodNumber;
+    }, z.core.$strip>>;
+    feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            success: "success";
+            warning: "warning";
+        }>;
+    }, z.core.$strip>>>;
+    allowRetry: z.ZodOptional<z.ZodBoolean>;
+    detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type BitResult = z.infer<typeof BitResultSchema>;
+/**
+ * Version of the attempt snapshot format, independent of the document format.
+ */
+export declare const ATTEMPT_SCHEMA_VERSION = 1;
+export declare const ConfidenceSchema: z.ZodObject<{
+    level: z.ZodNumber;
+}, z.core.$strip>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+export declare const AttemptStatusSchema: z.ZodEnum<{
+    abandoned: "abandoned";
+    completed: "completed";
+    inProgress: "inProgress";
+}>;
+export type AttemptStatus = z.infer<typeof AttemptStatusSchema>;
+/**
+ * Everything needed to resume a run. Serializable by construction: the host
+ * persists it verbatim (see `bitflow-statechange`) and hands it back later.
+ *
+ * `history`, `elapsedMs` and `enteredAt` are part of version 1 because
+ * "go back" and per-node timings cannot be reconstructed from the graph once
+ * branching is condition-driven.
+ */
+export declare const AttemptSnapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    flowId: z.ZodString;
+    flowSchemaVersion: z.ZodNumber;
+    attemptId: z.ZodString;
+    status: z.ZodEnum<{
+        abandoned: "abandoned";
+        completed: "completed";
+        inProgress: "inProgress";
+    }>;
+    currentNodeId: z.ZodString;
+    history: z.ZodArray<z.ZodString>;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    results: z.ZodRecord<z.ZodString, z.ZodObject<{
+        state: z.ZodEnum<{
+            correct: "correct";
+            unknown: "unknown";
+            wrong: "wrong";
+        }>;
+        score: z.ZodOptional<z.ZodObject<{
+            earned: z.ZodNumber;
+            possible: z.ZodNumber;
+        }, z.core.$strip>>;
+        feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            message: z.ZodString;
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                success: "success";
+                warning: "warning";
+            }>;
+        }, z.core.$strip>>>;
+        allowRetry: z.ZodOptional<z.ZodBoolean>;
+        detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    tries: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    elapsedMs: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    pools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    confidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        level: z.ZodNumber;
+    }, z.core.$strip>>>;
+    reasoning: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    startedAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    enteredAt: z.ZodISODateTime;
+    completedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type AttemptSnapshot = z.infer<typeof AttemptSnapshotSchema>;
+export {};

package/dist/score.d.ts

@@ -0,0 +1,18 @@
+import type { BitResult } from "./schema";
+/**
+ * A bit's result may carry its own `score`. When it does not, the bit is worth
+ * one point, earned iff the state is `correct`. `unknown` contributes nothing
+ * to either side: it was never graded, so it must not drag the ratio down.
+ *
+ * Its own module rather than living in `engine.ts` because conditions score a
+ * scoped set of results, and `engine.ts` imports `condition.ts` — putting it
+ * here is what keeps that from becoming a cycle.
+ */
+export declare const scoreOf: (result: BitResult) => {
+    earned: number;
+    possible: number;
+};
+export declare const totalScore: (results: Iterable<BitResult>) => {
+    earned: number;
+    possible: number;
+};

package/dist/styles.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adds a package's stylesheet to the document, once.
+ *
+ * Each package's CSS is bundled into its JavaScript as a string and injected
+ * on import, rather than shipped as a file the page has to remember to link.
+ * That is what makes "import the bit package" the single action that makes a
+ * bit usable: `<bitflow-flow>` resolves bits at runtime, so no page can know in
+ * advance which stylesheets to include, and a lazily loaded bit that arrives
+ * unstyled is not usable.
+ *
+ * `id` deduplicates: several bundles on one page inject the same shared
+ * stylesheet, and the first one is enough.
+ */
+export declare const injectStyles: (id: string, css: string) => void;