@kanonak-protocol/cli 1.4.0 → 1.6.0

package/dist/skills/SkillPaths.d.ts

@@ -1,27 +1,40 @@
+import type { IKanonakDocumentRepository } from '@kanonak-protocol/sdk';
 /**
  * Options for resolving skill discovery paths.
  */
 export interface SkillPathOptions {
+    /**
+     * clientId of a named Client instance in the agent-skills ontology
+     * (e.g. "agents", "claude-code"). When omitted, the CLI first tries
+     * `detectClient()` on process env vars, then falls back to the
+     * "agents" cross-client default.
+     */
     client?: string;
+    /** "project" (default) or "user". */
     scope?: string;
 }
 /**
- * Resolve the skills directory based on client and scope options.
+ * Resolve the skills directory for the requested client and scope.
  *
- * Discovery paths per the agent-skills ontology:
- *   project + client:  {cwd}/.<client>/skills/
- *   project + none:    {cwd}/.agents/skills/
- *   user + client:     ~/.<client>/skills/
- *   user + none:       ~/.agents/skills/
+ * This goes through the SDK object model: the agent-skills ontology
+ * is parsed, Client instances are looked up by URI, and the matching
+ * Client's `projectSkillDir` or `userSkillDir` is read. No hardcoded
+ * path templates, no alias string-stripping — the installer adapts
+ * to whatever named Client instances exist in the ontology at
+ * runtime.
  */
-export declare function resolveSkillsDir(options: SkillPathOptions): string;
+export declare function resolveSkillsDir(options: SkillPathOptions, repository: IKanonakDocumentRepository): Promise<string>;
 /**
- * Resolve the directory for a specific skill.
+ * Resolve the directory for a specific skill by name.
  */
-export declare function resolveSkillDir(skillName: string, options: SkillPathOptions): string;
+export declare function resolveSkillDir(skillName: string, options: SkillPathOptions, repository: IKanonakDocumentRepository): Promise<string>;
 /**
  * Auto-detect the current AI agent client from environment variables.
+ * Returns a clientId matching a named Client instance in the
+ * agent-skills ontology, or undefined when nothing is detected.
  *
- * Returns the client name (lowercase) or undefined if not detected.
+ * Matches the default Client instances declared in
+ * kanonak.org/agent-skills@1.1.0. Extend this mapping when adding
+ * new named Client instances with their own env-var signature.
  */
 export declare function detectClient(): string | undefined;

package/dist/transformations/CompiledTransformation.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Typed, parsed-once representation of a Transformation ontology
+ * instance. Produced by `TransformationLoader` from a `SubjectKanonak`
+ * of type `kanonak.org/transformations/Transformation`; consumed by
+ * `TransformationRunner` and `ExpressionEngine`.
+ *
+ * Separating the compiled form from the raw SDK object model means
+ * expression evaluation is a plain-data walk with no repeated
+ * predicate-URI matching per step. Compilation validates shape and
+ * throws with a BuilderNode path breadcrumb on first error.
+ */
+import type { EntityUri } from '../capabilities/UriHelpers.js';
+export type NormalizeKindName = 'trim-end';
+export interface CompiledTransformation {
+    /** The transformation entity's own local name, for diagnostics. */
+    name: string;
+    inputPattern: CompiledInputPattern;
+    rule: CompiledExpression;
+    artifactName: CompiledExpression;
+    /**
+     * The set of OutputFormat URIs this transformation supports,
+     * keyed by the OutputFormat's local name (not its backendUri).
+     * The runner rejects requests to render in a format not in this set.
+     */
+    outputs: Set<string>;
+    /**
+     * Per-format overrides keyed by the OutputFormat's local name.
+     */
+    overrides: Map<string, CompiledFormatOverride>;
+}
+export interface CompiledInputPattern {
+    /** The class URI whose instances this transformation matches. */
+    matchesClass: EntityUri;
+    /**
+     * Property URIs that must resolve to a non-empty value on the
+     * input subject. Missing-required instances are silently skipped.
+     */
+    requires: EntityUri[];
+}
+export interface CompiledFormatOverride {
+    /**
+     * Optional include list of metadata entry keys the backend should
+     * emit, in order. Keys outside this list are skipped. If omitted,
+     * the backend emits all metadata entries in their AST order.
+     */
+    metadataKeys?: string[];
+    /** AST-key → emitted-key renames. */
+    metadataRenames: Map<string, string>;
+    /** Whether to append a final newline to the serialized output. */
+    trailingNewline?: boolean;
+}
+export type CompiledExpression = CompiledBuildAstNode | CompiledForEach | CompiledWhen | CompiledConcat | CompiledStringLiteral | CompiledIntegerLiteral | CompiledBooleanLiteral | CompiledVarRef | CompiledPropertyRead | CompiledTraverse | CompiledFallback | CompiledUriName | CompiledListMap | CompiledJoin | CompiledNormalize | CompiledIsSet | CompiledUriLiteral | CompiledDisplayLabel;
+export interface CompiledBuildAstNode {
+    kind: 'build-ast-node';
+    astClass: EntityUri;
+    set: CompiledBinding[];
+}
+export interface CompiledForEach {
+    kind: 'for-each';
+    iterate: CompiledExpression;
+    loopVar: string;
+    emit: CompiledExpression;
+}
+export interface CompiledWhen {
+    kind: 'when';
+    condition: CompiledExpression;
+    thenBuild: CompiledExpression;
+    elseBuild?: CompiledExpression;
+}
+export interface CompiledConcat {
+    kind: 'concat';
+    parts: CompiledExpression[];
+}
+export interface CompiledStringLiteral {
+    kind: 'string-literal';
+    value: string;
+}
+export interface CompiledIntegerLiteral {
+    kind: 'integer-literal';
+    value: number;
+}
+export interface CompiledBooleanLiteral {
+    kind: 'boolean-literal';
+    value: boolean;
+}
+export interface CompiledVarRef {
+    kind: 'var-ref';
+    varName: string;
+}
+export interface CompiledPropertyRead {
+    kind: 'property-read';
+    source: CompiledExpression;
+    readProp: EntityUri;
+}
+export interface CompiledTraverse {
+    kind: 'traverse';
+    source: CompiledExpression;
+    through: EntityUri;
+    step: CompiledExpression;
+}
+export interface CompiledFallback {
+    kind: 'fallback';
+    primary: CompiledExpression;
+    alternate: CompiledExpression;
+}
+export interface CompiledUriName {
+    kind: 'uri-name';
+    of: CompiledExpression;
+}
+export interface CompiledListMap {
+    kind: 'list-map';
+    source: CompiledExpression;
+    loopVar: string;
+    mapBody: CompiledExpression;
+}
+export interface CompiledJoin {
+    kind: 'join';
+    separator: string;
+    items: CompiledExpression;
+}
+export interface CompiledNormalize {
+    kind: 'normalize';
+    source: CompiledExpression;
+    normKind: NormalizeKindName;
+}
+export interface CompiledIsSet {
+    kind: 'is-set';
+    check: CompiledExpression;
+}
+export interface CompiledUriLiteral {
+    kind: 'uri-literal';
+    refTo: EntityUri;
+}
+export interface CompiledDisplayLabel {
+    kind: 'display-label';
+    /** The entity whose display label this expression resolves. */
+    labelTarget: EntityUri;
+    /** The property to read off the target for the display value. */
+    labelSource: EntityUri;
+}
+export interface CompiledBinding {
+    /** The document-ast property URI being bound. */
+    field: EntityUri;
+    /** Expression that produces the bound value. */
+    value: CompiledExpression;
+}

package/dist/transformations/DocAst.d.ts

@@ -0,0 +1,84 @@
+/**
+ * In-memory document AST types.
+ *
+ * Runtime-only: built by the ExpressionEngine during transformation
+ * evaluation, consumed by format backends. The ontology in
+ * `kanonak.org/document-ast@1.0.0` is the external contract; these
+ * TypeScript types are the internal representation.
+ *
+ * Each node carries a `kind` discriminant whose value is the local
+ * name of the document-ast Class URI (e.g. `'Document'`, `'Heading'`).
+ * The discriminant is a plain string because the AST never leaves the
+ * runner — no Kanonak URI comparisons happen against AST nodes, only
+ * against the ontology entities that describe them.
+ *
+ * `escapeHint` is a full EntityUri, not a string, so backends compare
+ * against `DOCAST.ESC_RAW` etc. via `uriMatches` — maintaining URI
+ * equality end-to-end.
+ */
+import type { EntityUri } from '../capabilities/UriHelpers.js';
+export interface DocAstDocument {
+    kind: 'Document';
+    metadata?: DocAstStructuredMap;
+    children: DocAstBlock[];
+}
+export type DocAstBlock = DocAstHeading | DocAstParagraph | DocAstRawBlock;
+export interface DocAstHeading {
+    kind: 'Heading';
+    level: number;
+    inlines: DocAstInline[];
+}
+export interface DocAstParagraph {
+    kind: 'Paragraph';
+    inlines: DocAstInline[];
+}
+/**
+ * Pre-formatted content in a declared media type. Borrowed from
+ * Pandoc's `RawBlock(format, content)`. The `mediaType` is a full
+ * EntityUri referencing a named MediaType instance from
+ * `kanonak.org/document-ast@1.0.0` (e.g. DOCAST.TEXT_MARKDOWN).
+ *
+ * Backends dispatch by URI: HTML runs markdown through a renderer,
+ * passes HTML through verbatim, and falls back to escaped `<pre>`
+ * for unknown media types. Markdown backends emit the content
+ * verbatim because it's already in a text format.
+ */
+export interface DocAstRawBlock {
+    kind: 'RawBlock';
+    mediaType?: EntityUri;
+    rawContent: string;
+}
+export type DocAstInline = DocAstText;
+export interface DocAstText {
+    kind: 'Text';
+    text: string;
+}
+export type DocAstStructuredValue = DocAstStructuredMap | DocAstStructuredList | DocAstStringScalar | DocAstIntegerScalar;
+export interface DocAstStructuredMap {
+    kind: 'StructuredMap';
+    entries: DocAstStructuredEntry[];
+}
+export interface DocAstStructuredEntry {
+    kind: 'StructuredEntry';
+    key: string;
+    value: DocAstStructuredValue;
+    /**
+     * Per-entry serialization hint — one of the named EscapeHint
+     * instances from `kanonak.org/document-ast@1.0.0`. Stored as a
+     * full `EntityUri` so backends compare by canonical URI, never
+     * by string local name.
+     */
+    escapeHint?: EntityUri;
+}
+export interface DocAstStructuredList {
+    kind: 'StructuredList';
+    items: DocAstStructuredValue[];
+}
+export interface DocAstStringScalar {
+    kind: 'StringScalar';
+    stringValue: string;
+}
+export interface DocAstIntegerScalar {
+    kind: 'IntegerScalar';
+    integerValue: number;
+}

package/dist/transformations/ExpressionEngine.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Evaluates a `CompiledExpression` tree against an input binding
+ * environment. Handles both value-producing kinds (property-read,
+ * traverse, fallback, ...) and structure-building kinds
+ * (build-ast-node, for-each, when, concat) under a single dispatch.
+ *
+ * All property reads walk `statement[]` by canonical predicate URI
+ * (via `UriHelpers`). Reference resolution during traverse goes
+ * through the shared `ReferenceResolver`. No string heuristics, no
+ * YAML hand-parsing.
+ */
+import { type Kanonak, type KanonakUri } from '@kanonak-protocol/sdk';
+import { ReferenceResolver } from './ReferenceResolver.js';
+import type { CompiledExpression } from './CompiledTransformation.js';
+import { DOCAST } from './UriConstants.js';
+export type EnvValue = string | number | boolean | Kanonak | Kanonak[] | KanonakUri | unknown[] | object | undefined | null;
+export type Env = Map<string, EnvValue>;
+export declare class ExpressionEvalError extends Error {
+    constructor(message: string);
+}
+export declare class ExpressionEngine {
+    private readonly resolver;
+    private readonly allKanonaks;
+    constructor(resolver: ReferenceResolver, allKanonaks: Kanonak[]);
+    evaluate(expr: CompiledExpression, env: Env): Promise<EnvValue>;
+    private buildAstNode;
+}
+export { DOCAST };

package/dist/transformations/ReferenceResolver.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolves a `KanonakUri` to its defining `SubjectKanonak`, following
+ * cross-package imports through a broader repository.
+ *
+ * Extracted from `SkillTransformer.ts:189-235` so the transformation
+ * engine and any other consumer can share a single cached resolver.
+ * Behavior is identical to the original — local shadowing first,
+ * then a cache-keyed lookup in the broader repository, with a final
+ * name-based fallback for edge cases where the parser emits a
+ * namespace string that doesn't start with the expected prefix.
+ */
+import { KanonakParser, KanonakObjectParser, SubjectKanonak, type Kanonak, type KanonakUri, type IKanonakDocumentRepository } from '@kanonak-protocol/sdk';
+export declare class ReferenceResolver {
+    private readonly repository;
+    private readonly parser;
+    private readonly objectParser;
+    private readonly cache;
+    constructor(repository: IKanonakDocumentRepository, parser: KanonakParser, objectParser: KanonakObjectParser);
+    resolveSubject(uri: KanonakUri, localKanonaks: Kanonak[]): Promise<SubjectKanonak | undefined>;
+}

package/dist/transformations/TransformationLoader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compiles a Kanonak `Transformation` subject into a typed
+ * CompiledTransformation. All property reads go through
+ * `UriHelpers`; no string matching, no YAML hand-parsing. Throws
+ * `TransformationLoadError` with a breadcrumb path on the first
+ * shape violation.
+ */
+import { SubjectKanonak, type Kanonak } from '@kanonak-protocol/sdk';
+import { type EntityUri } from '../capabilities/UriHelpers.js';
+import type { CompiledTransformation } from './CompiledTransformation.js';
+export declare class TransformationLoadError extends Error {
+    readonly path: string;
+    constructor(message: string, path: string);
+}
+export declare function compileTransformation(transformation: SubjectKanonak, allKanonaks: Kanonak[]): CompiledTransformation;
+/**
+ * Reference to a transformations-ontology entity (used externally
+ * to look up named Transformation instances by local name).
+ */
+export declare function findTransformation(kanonaks: Kanonak[], uri: EntityUri): SubjectKanonak | undefined;

package/dist/transformations/TransformationRunner.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Top-level entry point for the generic transformation runner.
+ *
+ * Given a Transformation SubjectKanonak, a list of candidate input
+ * instances, the broader repository (for reference resolution), and
+ * the desired OutputFormat, produces a list of in-memory `Artifact`
+ * records. The runner never touches the filesystem — writing is the
+ * deployment handler's job.
+ *
+ * Pipeline per input:
+ *   1. Filter by InputPattern.matchesClass + requires.
+ *   2. Evaluate `rule` → DocAstDocument.
+ *   3. Evaluate `artifactName` → filename stem.
+ *   4. Look up backend by OutputFormat's local name.
+ *   5. Apply FormatOverride for that format if present.
+ *   6. Serialize → bytes → wrap as Artifact.
+ */
+import { KanonakParser, KanonakObjectParser, SubjectKanonak, type Kanonak, type IKanonakDocumentRepository } from '@kanonak-protocol/sdk';
+import type { IDocumentAstBackend } from './backends/IDocumentAstBackend.js';
+export interface Artifact {
+    /** Filename stem with no directory and no extension. */
+    fileName: string;
+    /** The OutputFormat local name this artifact was serialized as. */
+    format: string;
+    /** The serialized bytes (UTF-8 string). */
+    content: string;
+    /** The source subject this artifact was produced from. */
+    sourceName: string;
+}
+export interface RunInput {
+    transformation: SubjectKanonak;
+    /** Candidate input subjects to run the transformation against. */
+    instances: SubjectKanonak[];
+    allKanonaks: Kanonak[];
+    /**
+     * Optional: the Kanonaks of the transformation's own package
+     * (plus any packages hosting fragments the transformation calls).
+     * Used at compile time to resolve `call-fragment` references. If
+     * the transformation does not use fragments this can be left
+     * undefined — the retrofit Skill/Agent cases pass nothing.
+     */
+    transformationKanonaks?: Kanonak[];
+    repository: IKanonakDocumentRepository;
+    parser: KanonakParser;
+    objectParser: KanonakObjectParser;
+    /** The OutputFormat local name (e.g. `'markdown-with-frontmatter'`). */
+    outputFormat: string;
+}
+export declare class TransformationRunnerError extends Error {
+}
+export declare class TransformationRunner {
+    private readonly backends;
+    constructor();
+    register(backend: IDocumentAstBackend): void;
+    run(input: RunInput): Promise<Artifact[]>;
+    private findBackendForFormat;
+}

package/dist/transformations/UriConstants.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Hardcoded canonical URIs for the document-ast and transformations
+ * ontologies. Per `typescript/CLAUDE.md` rule 6, hardcoded URI
+ * constants are fine and expected — they are the ontology contract.
+ * String-based alias or suffix matching is NOT.
+ *
+ * Every comparison in the runner is KanonakUri → EntityUri equality
+ * (publisher + package + name), never string manipulation of YAML
+ * keys or alias prefixes.
+ */
+import type { EntityUri } from '../capabilities/UriHelpers.js';
+export declare const DOCAST_PUB = "kanonak.org";
+export declare const DOCAST_PKG = "document-ast";
+export declare const DOCAST: {
+    readonly Document: EntityUri;
+    readonly Block: EntityUri;
+    readonly Inline: EntityUri;
+    readonly StructuredValue: EntityUri;
+    readonly Heading: EntityUri;
+    readonly Paragraph: EntityUri;
+    readonly RawBlock: EntityUri;
+    readonly Text: EntityUri;
+    readonly StructuredMap: EntityUri;
+    readonly StructuredEntry: EntityUri;
+    readonly StructuredList: EntityUri;
+    readonly StringScalar: EntityUri;
+    readonly IntegerScalar: EntityUri;
+    readonly EscapeHint: EntityUri;
+    readonly MediaType: EntityUri;
+    readonly metadata: EntityUri;
+    readonly children: EntityUri;
+    readonly level: EntityUri;
+    readonly inlines: EntityUri;
+    readonly text: EntityUri;
+    readonly entries: EntityUri;
+    readonly key: EntityUri;
+    readonly value: EntityUri;
+    readonly escapeHint: EntityUri;
+    readonly items: EntityUri;
+    readonly stringValue: EntityUri;
+    readonly integerValue: EntityUri;
+    readonly rawContent: EntityUri;
+    readonly mediaType: EntityUri;
+    readonly mimeType: EntityUri;
+    readonly ESC_RAW: EntityUri;
+    readonly ESC_YAML_SAFE: EntityUri;
+    readonly ESC_TOML_STRING: EntityUri;
+    readonly ESC_TOML_MULTILINE: EntityUri;
+    readonly ESC_JSON: EntityUri;
+    readonly TEXT_PLAIN: EntityUri;
+    readonly TEXT_MARKDOWN: EntityUri;
+    readonly TEXT_HTML: EntityUri;
+    readonly APPLICATION_JSON: EntityUri;
+    readonly TEXT_YAML: EntityUri;
+    readonly IMAGE_SVG_XML: EntityUri;
+};
+export declare const TX_PUB = "kanonak.org";
+export declare const TX_PKG = "transformations";
+export declare const TX: {
+    readonly Transformation: EntityUri;
+    readonly InputPattern: EntityUri;
+    readonly Expression: EntityUri;
+    readonly ExpressionKind: EntityUri;
+    readonly ExpressionFragment: EntityUri;
+    readonly AstFieldBinding: EntityUri;
+    readonly OutputFormat: EntityUri;
+    readonly FormatOverride: EntityUri;
+    readonly RenameEntry: EntityUri;
+    readonly Artifact: EntityUri;
+    readonly NormalizeKind: EntityUri;
+    readonly inputPattern: EntityUri;
+    readonly rule: EntityUri;
+    readonly artifactName: EntityUri;
+    readonly outputs: EntityUri;
+    readonly formatOverrides: EntityUri;
+    readonly matchesClass: EntityUri;
+    readonly requires: EntityUri;
+    readonly kind: EntityUri;
+    readonly astClass: EntityUri;
+    readonly set: EntityUri;
+    readonly iterate: EntityUri;
+    readonly loopVar: EntityUri;
+    readonly emit: EntityUri;
+    readonly condition: EntityUri;
+    readonly thenBuild: EntityUri;
+    readonly elseBuild: EntityUri;
+    readonly parts: EntityUri;
+    readonly stringLiteral: EntityUri;
+    readonly integerLiteral: EntityUri;
+    readonly booleanLiteral: EntityUri;
+    readonly varName: EntityUri;
+    readonly readSource: EntityUri;
+    readonly readProp: EntityUri;
+    readonly traverseSource: EntityUri;
+    readonly through: EntityUri;
+    readonly step: EntityUri;
+    readonly primary: EntityUri;
+    readonly alternate: EntityUri;
+    readonly uriNameOf: EntityUri;
+    readonly listMapSource: EntityUri;
+    readonly mapBody: EntityUri;
+    readonly separator: EntityUri;
+    readonly items: EntityUri;
+    readonly normSource: EntityUri;
+    readonly normKind: EntityUri;
+    readonly checkExpr: EntityUri;
+    readonly refTo: EntityUri;
+    readonly fragmentRef: EntityUri;
+    readonly expr: EntityUri;
+    readonly labelTarget: EntityUri;
+    readonly labelSource: EntityUri;
+    readonly field: EntityUri;
+    readonly bindValue: EntityUri;
+    readonly backendUri: EntityUri;
+    readonly formatTarget: EntityUri;
+    readonly metadataKeys: EntityUri;
+    readonly metadataRenames: EntityUri;
+    readonly trailingNewline: EntityUri;
+    readonly fromKey: EntityUri;
+    readonly toKey: EntityUri;
+    readonly KIND_BUILD_AST_NODE: EntityUri;
+    readonly KIND_FOR_EACH: EntityUri;
+    readonly KIND_WHEN: EntityUri;
+    readonly KIND_CONCAT: EntityUri;
+    readonly KIND_STRING_LITERAL: EntityUri;
+    readonly KIND_INTEGER_LITERAL: EntityUri;
+    readonly KIND_BOOLEAN_LITERAL: EntityUri;
+    readonly KIND_VAR_REF: EntityUri;
+    readonly KIND_PROPERTY_READ: EntityUri;
+    readonly KIND_TRAVERSE: EntityUri;
+    readonly KIND_FALLBACK: EntityUri;
+    readonly KIND_URI_NAME: EntityUri;
+    readonly KIND_LIST_MAP: EntityUri;
+    readonly KIND_JOIN: EntityUri;
+    readonly KIND_NORMALIZE: EntityUri;
+    readonly KIND_IS_SET: EntityUri;
+    readonly KIND_URI_LITERAL: EntityUri;
+    readonly KIND_CALL_FRAGMENT: EntityUri;
+    readonly KIND_DISPLAY_LABEL: EntityUri;
+    readonly NORM_TRIM_END: EntityUri;
+    readonly FMT_MARKDOWN_FRONTMATTER: EntityUri;
+    readonly FMT_TOML: EntityUri;
+    readonly FMT_JSON: EntityUri;
+    readonly FMT_PLAIN_MARKDOWN: EntityUri;
+};

package/dist/transformations/backends/HtmlBackend.d.ts

@@ -0,0 +1,7 @@
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
+export declare class HtmlBackend implements IDocumentAstBackend {
+    readonly backendUri = "kanonak.org/transformations/backend/html";
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}

package/dist/transformations/backends/IDocumentAstBackend.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Format backend interface. Given a document-ast Document tree and
+ * an optional per-transformation format override, produce the
+ * serialized bytes of the artifact as a string.
+ *
+ * Backends are pure functions of (document, override) — they never
+ * touch the filesystem or the repository. That's the deployment
+ * handler's job.
+ */
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+export interface IDocumentAstBackend {
+    /** The backendUri string this backend registers under. */
+    readonly backendUri: string;
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}

package/dist/transformations/backends/JsonBackend.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trivial JSON backend. Serializes the full Document (both channels)
+ * as pretty-printed JSON. Useful as a regression-test oracle that is
+ * immune to the whitespace sensitivity of the text backends.
+ */
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
+export declare class JsonBackend implements IDocumentAstBackend {
+    readonly backendUri = "kanonak.org/transformations/backend/json";
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}

package/dist/transformations/backends/MarkdownFrontmatterBackend.d.ts

@@ -0,0 +1,7 @@
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
+export declare class MarkdownFrontmatterBackend implements IDocumentAstBackend {
+    readonly backendUri = "kanonak.org/transformations/backend/markdown-with-frontmatter";
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}

package/dist/transformations/backends/SimpleMarkdownRenderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimal CommonMark-ish markdown → HTML renderer.
+ *
+ * Covers the subset of markdown the Skill hasSection bodies actually
+ * use: ATX headings (# through ######), paragraphs, fenced code
+ * blocks (```lang\n...\n```), inline code (`code`), bold (**text**),
+ * italic (*text* or _text_), unordered lists (- or * item), ordered
+ * lists (1. item), links ([text](url)), and GitHub-flavored tables
+ * (| header | header | ... |). Does NOT handle blockquotes,
+ * reference-style links, HTML passthrough, setext headings, or
+ * pipe-escape in table cells.
+ *
+ * Intentionally self-contained (no dependencies). If a real CommonMark
+ * implementation is ever needed, swap this file out — nothing else in
+ * the transformation system depends on its internals.
+ */
+export declare function renderMarkdownToHtml(source: string): string;

package/dist/transformations/backends/SvgBackend.d.ts

@@ -0,0 +1,7 @@
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
+export declare class SvgBackend implements IDocumentAstBackend {
+    readonly backendUri = "kanonak.org/transformations/backend/svg";
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}

package/dist/transformations/backends/TomlBackend.d.ts

@@ -0,0 +1,7 @@
+import type { DocAstDocument } from '../DocAst.js';
+import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
+export declare class TomlBackend implements IDocumentAstBackend {
+    readonly backendUri = "kanonak.org/transformations/backend/toml";
+    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+}