explico 0.8.0 → 0.11.1

package/dist/rules/course-rules.d.ts

@@ -0,0 +1,115 @@
+import { CourseRuleId, Element, RuleEntry } from './catalog.js';
+
+/**
+ * A course's own rules — `courseRules` in `course.settings.json`.
+ *
+ * The engine ships the `N` / `V` / `C` / `S` / `P` areas and a course tunes or
+ * turns them off through `rules` (`src/rules/settings.ts`). This is the other
+ * half: a classroom's house style, written and edited by the people who teach
+ * the course, with no engine change and no fork. `X` is permanently reserved
+ * for them, so an `X` rule reads like any other rule everywhere it appears —
+ * a diagnostic, a waiver, the rules-in-effect page, a review comment.
+ *
+ * ```json
+ * "courseRules": [
+ *   {
+ *     "id": "X1",
+ *     "title": "A paragraph never ends in an exclamation.",
+ *     "summary": "End a paragraph on a statement…",
+ *     "severity": "error",
+ *     "forbid": [{ "scope": "paragraph", "pattern": "Ni!$", "message": "…" }]
+ *   },
+ *   { "id": "X2", "title": "Every fifth paragraph is four sentences.", "enabled": false }
+ * ]
+ * ```
+ *
+ * A rule with a `forbid` pattern is **enforced**: the pattern is matched
+ * against prose the same way rule N9's gate sees it (`gate-course-rules.ts`),
+ * and each match is a diagnostic at the rule's `severity`, carrying the rule's
+ * ID as its code — so `enforcementOf` calls it `script`, and it can be waived
+ * at one place with `{/* explico-allow X1: reason *\/}` like any located rule.
+ * A rule with no pattern is a **guide**: it appears on the rules-in-effect page
+ * for an author or an agent to follow, and nothing runs. `enabled: false`
+ * keeps a rule in the file and moves it to the page's "Off" list — the way to
+ * park a house rule that is drafted but not yet in force.
+ *
+ * Everything here is validated strictly and throws: the settings file is the
+ * course's own, a mistake in it is a mistake the author wants to hear about
+ * before a build runs with a rule that silently does nothing.
+ */
+
+/** Where a `forbid` pattern is matched. */
+type CourseRuleScope = 'paragraph' | 'prose' | 'heading';
+declare const COURSE_RULE_SCOPES: readonly CourseRuleScope[];
+/**
+ * One forbidden pattern, as the settings file gives it. `scope` is a plain
+ * `string` on purpose: this is the shape of untrusted JSON, and a
+ * `course.settings.json` imported by `course.config.ts` widens every literal to
+ * `string`, so a union here would make the course's own file fail to typecheck.
+ * The value is checked at resolve time, with the setting's path in the message.
+ */
+interface CourseRulePatternInput {
+    readonly pattern: string;
+    readonly flags?: string;
+    readonly scope?: string;
+    readonly message?: string;
+}
+/** One course rule, as the settings file gives it. See {@link CourseRulePatternInput}. */
+interface CourseRuleInput {
+    readonly id: string;
+    readonly title: string;
+    readonly summary?: string;
+    readonly elements?: readonly string[];
+    readonly enabled?: boolean;
+    readonly severity?: string;
+    readonly forbid?: readonly CourseRulePatternInput[];
+    readonly unchecked?: string;
+    readonly doc?: string;
+}
+/** `CourseConfig.courseRules` — an array, so the settings form can add and remove one. */
+type CourseRuleDefinitions = readonly CourseRuleInput[];
+interface CourseRulePattern {
+    readonly pattern: string;
+    readonly flags: string;
+    readonly scope: CourseRuleScope;
+    readonly message: string;
+}
+/** A course rule with every default applied and every value checked. */
+interface CourseRule {
+    readonly id: CourseRuleId;
+    readonly title: string;
+    readonly summary: string;
+    readonly elements: readonly [Element, ...Element[]];
+    readonly enabled: boolean;
+    readonly severity: 'error' | 'warning';
+    readonly forbid: readonly CourseRulePattern[];
+    readonly unchecked?: string;
+    readonly doc?: string;
+}
+/**
+ * Validate `config.courseRules` and apply the defaults. Throws on anything that
+ * would leave a rule doing something the author did not write: an ID outside
+ * the `X` namespace, a duplicate ID, an unknown key, a pattern that does not
+ * compile.
+ */
+declare function resolveCourseRules(config: {
+    readonly courseRules?: CourseRuleDefinitions;
+}): readonly CourseRule[];
+/**
+ * A course rule as a catalog entry, so the rules-in-effect page, the waiver
+ * validator and `enforcementOf` treat it like any other rule. Its one check
+ * carries the rule's ID as its code, and is `located` — every finding names a
+ * lesson file and line, which is what makes an inline waiver possible.
+ */
+declare function courseRuleEntry(rule: CourseRule): RuleEntry;
+type JsonSchema = Record<string, unknown>;
+/**
+ * The `courseRules` property for a course's `course.settings.schema.json`,
+ * written to `dist/rules/course-rules.schema.json` by
+ * `scripts/gen-rules-schema.mjs`. Self-contained (no `$ref`), so the settings
+ * form editor can inline it: an array of objects, which is what gives the form
+ * its add / remove / reorder controls.
+ */
+declare function courseRulesJsonSchema(): JsonSchema;
+
+export { COURSE_RULE_SCOPES, type CourseRule, type CourseRuleDefinitions, type CourseRuleInput, type CourseRulePattern, type CourseRulePatternInput, type CourseRuleScope, courseRuleEntry, courseRulesJsonSchema, resolveCourseRules };

package/dist/rules/course-rules.js

@@ -0,0 +1,292 @@
+import {
+  ELEMENTS,
+  isCourseRuleId
+} from "./catalog.js";
+const COURSE_RULE_SCOPES = ["paragraph", "prose", "heading"];
+const ALLOWED_FLAGS = "imsu";
+const SETTINGS_DOC = "../content/course.settings.json";
+function describe(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function at(index, id) {
+  return `CourseConfig courseRules[${index}]${id === void 0 ? "" : ` (${id})`}`;
+}
+function requireString(value, where) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${where} must be a non-empty string; received ${describe(value)}.`);
+  }
+  return value;
+}
+function resolveElements(value, where) {
+  if (value === void 0) return ["prose"];
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(
+      `${where}.elements must be a non-empty array of elements; received ${describe(value)}.`
+    );
+  }
+  for (const element of value) {
+    if (!ELEMENTS.includes(element)) {
+      throw new Error(
+        `${where}.elements: ${describe(element)} is not an element. One of: ${ELEMENTS.join(", ")}.`
+      );
+    }
+  }
+  return value;
+}
+function resolvePattern(input, where, index, fallbackMessage) {
+  const spot = `${where}.forbid[${index}]`;
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(
+      `${spot} must be an object such as { "pattern": "\u2026" }; received ${describe(input)}.`
+    );
+  }
+  const raw = input;
+  for (const key of Object.keys(raw)) {
+    if (!["pattern", "flags", "scope", "message"].includes(key)) {
+      throw new Error(`${spot}: unknown key \`${key}\`. Takes: pattern, flags, scope, message.`);
+    }
+  }
+  const pattern = requireString(raw.pattern, `${spot}.pattern`);
+  const flags = raw.flags === void 0 ? "" : requireString(raw.flags, `${spot}.flags`);
+  for (const flag of flags) {
+    if (!ALLOWED_FLAGS.includes(flag)) {
+      throw new Error(
+        `${spot}.flags: \`${flag}\` is not allowed. Use any of \`${ALLOWED_FLAGS}\` \u2014 \`g\` is always applied.`
+      );
+    }
+  }
+  if (new Set(flags).size !== flags.length) {
+    throw new Error(`${spot}.flags: ${describe(flags)} repeats a flag.`);
+  }
+  const scope = raw.scope === void 0 ? "paragraph" : raw.scope;
+  if (!COURSE_RULE_SCOPES.includes(scope)) {
+    throw new Error(
+      `${spot}.scope: ${describe(scope)} is not a scope. One of: ${COURSE_RULE_SCOPES.join(", ")}.`
+    );
+  }
+  let compiled;
+  try {
+    compiled = new RegExp(pattern, `${flags}g`);
+  } catch (error) {
+    throw new Error(
+      `${spot}.pattern: ${pattern} is not a valid regular expression \u2014 ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (compiled.test("")) {
+    throw new Error(
+      `${spot}.pattern: ${pattern} matches the empty string, so it would flag every ${scope}. Make it match the text you mean to forbid.`
+    );
+  }
+  const message = raw.message === void 0 ? fallbackMessage : requireString(raw.message, `${spot}.message`);
+  return { pattern, flags, scope, message };
+}
+function resolveCourseRules(config) {
+  const given = config.courseRules;
+  if (given === void 0) return [];
+  if (!Array.isArray(given)) {
+    throw new Error(
+      `CourseConfig courseRules must be an array of rules; received ${describe(given)}. It is a list, not a map, so the settings form can add and remove one.`
+    );
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const out = [];
+  given.forEach((input, index) => {
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+      throw new Error(
+        `${at(index)} must be an object such as { "id": "X1", "title": "\u2026" }; received ${describe(input)}.`
+      );
+    }
+    const raw = input;
+    const known = ["id", "title", "summary", "elements", "enabled", "severity", "forbid", "unchecked", "doc"];
+    for (const key of Object.keys(raw)) {
+      if (!known.includes(key)) {
+        throw new Error(`${at(index)}: unknown key \`${key}\`. Takes: ${known.join(", ")}.`);
+      }
+    }
+    const id = requireString(raw.id, `${at(index)}.id`);
+    if (!isCourseRuleId(id)) {
+      throw new Error(
+        `${at(index)}.id: ${describe(id)} is not a course-rule ID. A course's own rules are \`X1\`\u2026\`X99\` \u2014 the \`X\` area is reserved for them, and the engine never ships one, so no release can collide with yours. To change an engine rule, use \`rules\` instead.`
+      );
+    }
+    const first = seen.get(id);
+    if (first !== void 0) {
+      throw new Error(
+        `${at(index, id)}.id: ${id} is already used by courseRules[${first}]. An ID names one rule.`
+      );
+    }
+    seen.set(id, index);
+    const where = at(index, id);
+    const title = requireString(raw.title, `${where}.title`);
+    const summary = raw.summary === void 0 ? title : requireString(raw.summary, `${where}.summary`);
+    const elements = resolveElements(raw.elements, where);
+    if (raw.enabled !== void 0 && typeof raw.enabled !== "boolean") {
+      throw new Error(`${where}.enabled must be true or false; received ${describe(raw.enabled)}.`);
+    }
+    if (raw.severity !== void 0 && raw.severity !== "error" && raw.severity !== "warning") {
+      throw new Error(
+        `${where}.severity must be "error" or "warning"; received ${describe(raw.severity)}.`
+      );
+    }
+    const forbidInput = raw.forbid;
+    if (forbidInput !== void 0 && !Array.isArray(forbidInput)) {
+      throw new Error(`${where}.forbid must be an array of patterns; received ${describe(forbidInput)}.`);
+    }
+    const forbid = (forbidInput ?? []).map(
+      (pattern, i) => resolvePattern(pattern, where, i, title)
+    );
+    if (raw.severity !== void 0 && forbid.length === 0) {
+      throw new Error(
+        `${where}.severity is set but the rule has no \`forbid\` pattern, so nothing is reported. Add a pattern, or drop \`severity\` and keep it a guide rule.`
+      );
+    }
+    out.push({
+      id,
+      title,
+      summary,
+      elements,
+      enabled: raw.enabled !== false,
+      severity: raw.severity ?? "error",
+      forbid,
+      ...raw.unchecked === void 0 ? {} : { unchecked: requireString(raw.unchecked, `${where}.unchecked`) },
+      ...raw.doc === void 0 ? {} : { doc: requireString(raw.doc, `${where}.doc`) }
+    });
+  });
+  return out;
+}
+function courseRuleEntry(rule) {
+  const checks = rule.forbid.length === 0 ? [] : [
+    {
+      code: rule.id,
+      severity: rule.severity,
+      located: true,
+      emitters: [
+        { module: "src/reference/gate-course-rules.ts", fn: "gateCourseRules" }
+      ]
+    }
+  ];
+  return {
+    kind: "rule",
+    id: rule.id,
+    title: rule.title,
+    elements: rule.elements,
+    doc: rule.doc ?? SETTINGS_DOC,
+    summary: rule.summary,
+    checks,
+    ...rule.unchecked === void 0 ? {} : { unchecked: rule.unchecked },
+    source: "course"
+  };
+}
+function courseRulesJsonSchema() {
+  return {
+    title: "Course rules",
+    description: "This course's own authoring rules, on top of the engine's. IDs are `X1`\u2026`X99` \u2014 the `X` area is reserved for a course, so no engine release collides with one. A rule with a `forbid` pattern is enforced by the build; a rule without one is a guide an author or an agent reads. Every rule here appears in `build/rules-in-effect.md` beside the engine's, and can be waived at one place with `{/* explico-allow X1: reason */}`.",
+    type: "array",
+    default: [],
+    items: {
+      title: "Course rule",
+      type: "object",
+      additionalProperties: false,
+      required: ["id", "title"],
+      properties: {
+        id: {
+          title: "ID",
+          description: "Permanent name of this rule, `X1`\u2026`X99`. It is what a diagnostic, a waiver and a review comment say. Never renumber a rule that is in use.",
+          type: "string",
+          pattern: "^X[1-9][0-9]?$",
+          "x-patternMessage": "An `X` and a number, 1\u201399 \u2014 for example `X1`."
+        },
+        title: {
+          title: "Rule",
+          description: 'One imperative sentence, as a rule page would open: "A paragraph never ends in an exclamation."',
+          type: "string",
+          minLength: 1,
+          "x-widget": "textarea"
+        },
+        summary: {
+          title: "What to do",
+          description: "One to three sentences telling an author or an agent how to comply \u2014 no rationale. This is what `build/rules-in-effect.md` prints. Defaults to the rule sentence.",
+          type: "string",
+          "x-widget": "textarea"
+        },
+        elements: {
+          title: "Elements",
+          description: "The parts of a page this rule is about; the first is primary and decides which section of the rules-in-effect page lists it.",
+          type: "array",
+          default: ["prose"],
+          items: { title: "Element", type: "string", enum: [...ELEMENTS] }
+        },
+        enabled: {
+          title: "Enabled",
+          description: 'Off: the rule stays in this file and moves to the "Off" list on the rules-in-effect page \u2014 nothing runs, and an agent neither applies it nor flags it in review. Use it to park a rule that is drafted but not in force.',
+          type: "boolean",
+          default: true
+        },
+        severity: {
+          title: "Severity",
+          description: "What a match of a `forbid` pattern is: an error fails `pnpm validate:content`, a warning is reported and does not. Only for a rule that has a pattern.",
+          type: "string",
+          enum: ["error", "warning"],
+          default: "error"
+        },
+        forbid: {
+          title: "Forbidden patterns",
+          description: "What makes this rule enforced. Each entry is a regular expression matched against the lesson text \u2014 with code, math, MDX comments and JSX tags blanked out first, exactly as rule N9 sees prose. Leave empty for a guide rule.",
+          type: "array",
+          default: [],
+          items: {
+            title: "Pattern",
+            type: "object",
+            additionalProperties: false,
+            required: ["pattern"],
+            properties: {
+              pattern: {
+                title: "Regular expression",
+                description: "JavaScript regular-expression source, e.g. `Ni!\\s*$`. It must not match the empty string.",
+                type: "string",
+                minLength: 1
+              },
+              scope: {
+                title: "Matched against",
+                description: "paragraph \u2014 each block of prose separated by a blank line, so `^` and `$` are its start and end. prose \u2014 the lesson's whole prose, so a pattern can span paragraphs. heading \u2014 the text of each Markdown heading.",
+                type: "string",
+                enum: [...COURSE_RULE_SCOPES],
+                default: "paragraph"
+              },
+              flags: {
+                title: "Flags",
+                description: "Any of `i` (ignore case), `m` (`^`/`$` match each line), `s` (`.` matches a newline), `u` (unicode). `g` is always applied.",
+                type: "string",
+                pattern: "^[imsu]*$",
+                "x-patternMessage": "Only the letters i, m, s and u."
+              },
+              message: {
+                title: "Message",
+                description: "What the build says at each match. Defaults to the rule sentence. Say what to do, not only what is wrong.",
+                type: "string",
+                "x-widget": "textarea"
+              }
+            }
+          }
+        },
+        unchecked: {
+          title: "Not checked",
+          description: 'What the patterns cannot see, in one clause ("that the four sentences are in OSV order"). On a rule that has patterns it marks the rule `partial`, so a reader knows a green build is not the whole rule; on a guide rule it says why no pattern could do the job.',
+          type: "string",
+          "x-widget": "textarea"
+        },
+        doc: {
+          title: "Full text",
+          description: "Link to the course page that states this rule in full, as it should appear on the rules-in-effect page (a path relative to `build/`, or a URL). Defaults to the settings file itself.",
+          type: "string"
+        }
+      }
+    }
+  };
+}
+export {
+  COURSE_RULE_SCOPES,
+  courseRuleEntry,
+  courseRulesJsonSchema,
+  resolveCourseRules
+};

package/dist/rules/course-rules.schema.json

@@ -0,0 +1,138 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$comment": "Generated by scripts/gen-rules-schema.mjs from src/rules/course-rules.ts — do not edit.",
+  "title": "Course rules",
+  "description": "This course's own authoring rules, on top of the engine's. IDs are `X1`…`X99` — the `X` area is reserved for a course, so no engine release collides with one. A rule with a `forbid` pattern is enforced by the build; a rule without one is a guide an author or an agent reads. Every rule here appears in `build/rules-in-effect.md` beside the engine's, and can be waived at one place with `{/* explico-allow X1: reason */}`.",
+  "type": "array",
+  "default": [],
+  "items": {
+    "title": "Course rule",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+      "id",
+      "title"
+    ],
+    "properties": {
+      "id": {
+        "title": "ID",
+        "description": "Permanent name of this rule, `X1`…`X99`. It is what a diagnostic, a waiver and a review comment say. Never renumber a rule that is in use.",
+        "type": "string",
+        "pattern": "^X[1-9][0-9]?$",
+        "x-patternMessage": "An `X` and a number, 1–99 — for example `X1`."
+      },
+      "title": {
+        "title": "Rule",
+        "description": "One imperative sentence, as a rule page would open: \"A paragraph never ends in an exclamation.\"",
+        "type": "string",
+        "minLength": 1,
+        "x-widget": "textarea"
+      },
+      "summary": {
+        "title": "What to do",
+        "description": "One to three sentences telling an author or an agent how to comply — no rationale. This is what `build/rules-in-effect.md` prints. Defaults to the rule sentence.",
+        "type": "string",
+        "x-widget": "textarea"
+      },
+      "elements": {
+        "title": "Elements",
+        "description": "The parts of a page this rule is about; the first is primary and decides which section of the rules-in-effect page lists it.",
+        "type": "array",
+        "default": [
+          "prose"
+        ],
+        "items": {
+          "title": "Element",
+          "type": "string",
+          "enum": [
+            "prose",
+            "math",
+            "equation",
+            "notation",
+            "heading",
+            "part-page",
+            "plot",
+            "diagram",
+            "table",
+            "assessment",
+            "source",
+            "changelog"
+          ]
+        }
+      },
+      "enabled": {
+        "title": "Enabled",
+        "description": "Off: the rule stays in this file and moves to the \"Off\" list on the rules-in-effect page — nothing runs, and an agent neither applies it nor flags it in review. Use it to park a rule that is drafted but not in force.",
+        "type": "boolean",
+        "default": true
+      },
+      "severity": {
+        "title": "Severity",
+        "description": "What a match of a `forbid` pattern is: an error fails `pnpm validate:content`, a warning is reported and does not. Only for a rule that has a pattern.",
+        "type": "string",
+        "enum": [
+          "error",
+          "warning"
+        ],
+        "default": "error"
+      },
+      "forbid": {
+        "title": "Forbidden patterns",
+        "description": "What makes this rule enforced. Each entry is a regular expression matched against the lesson text — with code, math, MDX comments and JSX tags blanked out first, exactly as rule N9 sees prose. Leave empty for a guide rule.",
+        "type": "array",
+        "default": [],
+        "items": {
+          "title": "Pattern",
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "pattern"
+          ],
+          "properties": {
+            "pattern": {
+              "title": "Regular expression",
+              "description": "JavaScript regular-expression source, e.g. `Ni!\\s*$`. It must not match the empty string.",
+              "type": "string",
+              "minLength": 1
+            },
+            "scope": {
+              "title": "Matched against",
+              "description": "paragraph — each block of prose separated by a blank line, so `^` and `$` are its start and end. prose — the lesson's whole prose, so a pattern can span paragraphs. heading — the text of each Markdown heading.",
+              "type": "string",
+              "enum": [
+                "paragraph",
+                "prose",
+                "heading"
+              ],
+              "default": "paragraph"
+            },
+            "flags": {
+              "title": "Flags",
+              "description": "Any of `i` (ignore case), `m` (`^`/`$` match each line), `s` (`.` matches a newline), `u` (unicode). `g` is always applied.",
+              "type": "string",
+              "pattern": "^[imsu]*$",
+              "x-patternMessage": "Only the letters i, m, s and u."
+            },
+            "message": {
+              "title": "Message",
+              "description": "What the build says at each match. Defaults to the rule sentence. Say what to do, not only what is wrong.",
+              "type": "string",
+              "x-widget": "textarea"
+            }
+          }
+        }
+      },
+      "unchecked": {
+        "title": "Not checked",
+        "description": "What the patterns cannot see, in one clause (\"that the four sentences are in OSV order\"). On a rule that has patterns it marks the rule `partial`, so a reader knows a green build is not the whole rule; on a guide rule it says why no pattern could do the job.",
+        "type": "string",
+        "x-widget": "textarea"
+      },
+      "doc": {
+        "title": "Full text",
+        "description": "Link to the course page that states this rule in full, as it should appear on the rules-in-effect page (a path relative to `build/`, or a URL). Defaults to the settings file itself.",
+        "type": "string"
+      }
+    }
+  }
+}

package/dist/rules/in-effect.d.ts

@@ -0,0 +1,53 @@
+import { Element, Enforcement } from './catalog.js';
+import { M as ManifestRules } from '../course-config-Dsnri9Tk.js';
+import './course-rules.js';
+
+/** The slice of a manifest the page needs. */
+interface RulesInEffectInput {
+    readonly rules: ManifestRules;
+    readonly about: {
+        readonly engine: {
+            readonly name: string;
+            readonly version: string;
+        };
+        readonly material: {
+            readonly name: string;
+        };
+        readonly knowledge: {
+            readonly version: string;
+        };
+    };
+}
+interface RulesFilter {
+    /** Keep a rule whose elements (any, not just primary) include one of these. */
+    readonly elements?: readonly Element[];
+    readonly enforcement?: Enforcement | 'locked';
+}
+/** One rule as `content rules --json` reports it. */
+interface RuleInEffect {
+    readonly id: string;
+    readonly kind: 'rule' | 'invariant';
+    /** `course` for one of this course's own `X` rules; `engine` for the rest. */
+    readonly source: 'engine' | 'course';
+    readonly title: string;
+    readonly elements: readonly Element[];
+    readonly enforcement: Enforcement | 'locked';
+    readonly enabled: boolean;
+    /** May be waived at one place with `{/* explico-allow <ID>: reason *\/}`. */
+    readonly waivable: boolean;
+    readonly codes: readonly string[];
+    readonly settings: Readonly<Record<string, unknown>>;
+    readonly summary: string;
+    readonly doc: string;
+}
+declare function rulesInEffect(input: RulesInEffectInput, filter?: RulesFilter): RuleInEffect[];
+/**
+ * The page. With a filter, only the matching rules are listed and the
+ * header says so; the Off / Locked / Always-on sections still list IDs so
+ * the reader knows what was left out on purpose.
+ */
+declare function renderRulesInEffect(input: RulesInEffectInput, filter?: RulesFilter): string;
+/** Write `build/rules-in-effect.md` under `root` (the course package). Returns the path. */
+declare function writeRulesInEffect(input: RulesInEffectInput, root?: string): string;
+
+export { type RuleInEffect, type RulesFilter, type RulesInEffectInput, renderRulesInEffect, rulesInEffect, writeRulesInEffect };