@kanonak-protocol/cli 2.5.0 → 3.0.0

package/dist/transformations/DocAstUriConstants.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Hardcoded canonical URIs for the document-ast ontology.
+ *
+ * Version-agnostic — docast is its own ontology and doesn't move
+ * with the transformations major version. Both the v2 runtime
+ * (legacy) and the v3 runtime read from this same file.
+ *
+ * Per the typescript repo's CLAUDE.md rule 6, hardcoded URI
+ * constants are fine and expected — they are the ontology contract.
+ * String-based alias or suffix matching is NOT.
+ */
+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;
+};

package/dist/transformations/FormatOverride.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Backend-facing FormatOverride contract.
+ *
+ * Version-agnostic — backends operate on docast trees and accept
+ * format-specific tweaks via this shape, regardless of which
+ * transformation runtime produced it. Each runtime version compiles
+ * its FormatOverride YAML into a value of this shape before handing
+ * it to a backend.
+ */
+export interface BackendFormatOverride {
+    /**
+     * 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;
+}

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

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

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

@@ -8,9 +8,9 @@
  * handler's job.
  */
 import type { DocAstDocument } from '../DocAst.js';
-import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { BackendFormatOverride } from '../FormatOverride.js';
 export interface IDocumentAstBackend {
     /** The backendUri string this backend registers under. */
     readonly backendUri: string;
-    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+    render(document: DocAstDocument, override?: BackendFormatOverride): string;
 }

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

@@ -4,9 +4,9 @@
  * immune to the whitespace sensitivity of the text backends.
  */
 import type { DocAstDocument } from '../DocAst.js';
-import type { CompiledFormatOverride } from '../CompiledTransformation.js';
+import type { BackendFormatOverride } from '../FormatOverride.js';
 import type { IDocumentAstBackend } from './IDocumentAstBackend.js';
 export declare class JsonBackend implements IDocumentAstBackend {
     readonly backendUri = "kanonak.org/transformations/json";
-    render(document: DocAstDocument, override?: CompiledFormatOverride): string;
+    render(document: DocAstDocument, override?: BackendFormatOverride): string;
 }

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

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

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

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

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

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

package/dist/transformations/v3/CompiledTransformationV3.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Typed, parsed-once representation of a transformations@3.0.0
+ * Transformation. Produced by `TransformationLoaderV3` from a
+ * `SubjectKanonak` whose RDF type is either `InstanceTransformation`
+ * or `SetTransformation`; consumed by `TransformationRunnerV3` and
+ * `ExpressionEngineV3`.
+ *
+ * The full Expression type union is declared here even though slice 1
+ * only implements a subset — declaring it upfront means later slices
+ * add behavior (loader cases, engine cases) rather than type members.
+ *
+ * V3 SHAPE NOTES (vs V2):
+ *   - Top level is a discriminated union over `kind: 'instance' | 'set'`,
+ *     mirroring the InstanceTransformation/SetTransformation split.
+ *   - InputPattern carries `sortBy` (ordered list of SortKeys); the V2
+ *     pattern had no sort.
+ *   - SetTransformation may carry `partitionBy` for fan-out.
+ *   - Expression nodes are tagged by their `kind` string here (the
+ *     compiled form), but in the YAML they're dispatched by RDF type
+ *     (real OWL hierarchy, not a discriminator instance).
+ */
+import type { EntityUri } from '../../capabilities/UriHelpers.js';
+export type CompiledTransformationV3 = CompiledInstanceTransformationV3 | CompiledSetTransformationV3;
+export interface CompiledTransformationV3Base {
+    /** Local name of the transformation entity, for diagnostics. */
+    name: string;
+    inputPattern: CompiledInputPatternV3;
+    rule: CompiledExpressionV3;
+    artifactName: CompiledExpressionV3;
+    /**
+     * The set of OutputFormat URIs this transformation supports, keyed
+     * by the OutputFormat's local name. The runner rejects requests to
+     * render in a format not in this set.
+     */
+    outputs: Set<string>;
+    /** Per-output-format overrides keyed by the OutputFormat's local name. */
+    overrides: Map<string, CompiledFormatOverrideV3>;
+}
+export interface CompiledInstanceTransformationV3 extends CompiledTransformationV3Base {
+    kind: 'instance';
+}
+export interface CompiledSetTransformationV3 extends CompiledTransformationV3Base {
+    kind: 'set';
+    /**
+     * When set, the runner partitions the matched input set on this
+     * property and emits one Artifact per partition; `key` and `inputs`
+     * are bound for each evaluation. When undefined, the runner runs
+     * `rule` and `artifactName` once with `inputs` bound to the whole
+     * matched set, emitting a single Artifact.
+     */
+    partitionBy?: EntityUri;
+}
+export interface CompiledInputPatternV3 {
+    /** The class URI whose instances are eligible. */
+    matchesClass: EntityUri;
+    /** Property URIs that must each resolve to non-empty on each instance. */
+    requires: EntityUri[];
+    /**
+     * Ordered list of sort criteria (primary first, ties broken by
+     * subsequent keys). Empty for transformations that don't need order.
+     */
+    sortBy: CompiledSortKeyV3[];
+}
+export interface CompiledSortKeyV3 {
+    byProperty: EntityUri;
+    order: 'ascending' | 'descending';
+}
+export interface CompiledFormatOverrideV3 {
+    metadataKeys?: string[];
+    metadataRenames: Map<string, string>;
+    trailingNewline?: boolean;
+}
+export type CompiledExpressionV3 = CompiledStringLiteralV3 | CompiledIntegerLiteralV3 | CompiledDecimalLiteralV3 | CompiledBooleanLiteralV3 | CompiledVarRefV3 | CompiledPropertyReadV3 | CompiledTraverseV3 | CompiledBuildAstNodeV3 | CompiledWhenV3 | CompiledConcatV3 | CompiledFallbackV3 | CompiledUriNameV3 | CompiledUriLiteralV3 | CompiledDisplayLabelV3 | CompiledResolveRefV3 | CompiledNormalizeV3 | CompiledIsSetV3 | CompiledCallFragmentV3 | CompiledJoinV3 | CompiledCountV3 | CompiledSumV3 | CompiledMinV3 | CompiledMaxV3 | CompiledAverageV3 | CompiledForEachV3 | CompiledListMapV3 | CompiledFilterV3 | CompiledPartitionByV3 | CompiledDistinctByV3;
+export interface CompiledStringLiteralV3 {
+    kind: 'string-literal';
+    value: string;
+}
+export interface CompiledIntegerLiteralV3 {
+    kind: 'integer-literal';
+    value: number;
+}
+export interface CompiledDecimalLiteralV3 {
+    kind: 'decimal-literal';
+    value: number;
+}
+export interface CompiledBooleanLiteralV3 {
+    kind: 'boolean-literal';
+    value: boolean;
+}
+export interface CompiledVarRefV3 {
+    kind: 'var-ref';
+    varName: string;
+}
+export interface CompiledPropertyReadV3 {
+    kind: 'property-read';
+    source: CompiledExpressionV3;
+    readProp: EntityUri;
+}
+export interface CompiledTraverseV3 {
+    kind: 'traverse';
+    source: CompiledExpressionV3;
+    through: EntityUri;
+    step: CompiledExpressionV3;
+}
+export interface CompiledBuildAstNodeV3 {
+    kind: 'build-ast-node';
+    astClass: EntityUri;
+    set: CompiledFieldBindingV3[];
+}
+export interface CompiledFieldBindingV3 {
+    field: EntityUri;
+    value: CompiledExpressionV3;
+}
+export interface CompiledWhenV3 {
+    kind: 'when';
+    condition: CompiledExpressionV3;
+    thenBuild: CompiledExpressionV3;
+    elseBuild?: CompiledExpressionV3;
+}
+export interface CompiledConcatV3 {
+    kind: 'concat';
+    parts: CompiledExpressionV3[];
+}
+export interface CompiledFallbackV3 {
+    kind: 'fallback';
+    primary: CompiledExpressionV3;
+    alternate: CompiledExpressionV3;
+}
+export interface CompiledUriNameV3 {
+    kind: 'uri-name';
+    source: CompiledExpressionV3;
+}
+export interface CompiledUriLiteralV3 {
+    kind: 'uri-literal';
+    refTo: EntityUri;
+}
+export interface CompiledDisplayLabelV3 {
+    kind: 'display-label';
+    labelTarget: EntityUri;
+    labelSource: EntityUri;
+}
+export interface CompiledResolveRefV3 {
+    kind: 'resolve-ref';
+    source: CompiledExpressionV3;
+}
+export type NormalizeKindV3 = 'trim-end';
+export interface CompiledNormalizeV3 {
+    kind: 'normalize';
+    source: CompiledExpressionV3;
+    normKind: NormalizeKindV3;
+}
+export interface CompiledIsSetV3 {
+    kind: 'is-set';
+    check: CompiledExpressionV3;
+}
+export interface CompiledCallFragmentV3 {
+    kind: 'call-fragment';
+    /** The fragment's compiled body, inlined at compile time. */
+    body: CompiledExpressionV3;
+}
+export interface CompiledJoinV3 {
+    kind: 'join';
+    source: CompiledExpressionV3;
+    separator: string;
+}
+export interface CompiledCountV3 {
+    kind: 'count';
+    source: CompiledExpressionV3;
+}
+export interface CompiledSumV3 {
+    kind: 'sum';
+    source: CompiledExpressionV3;
+}
+export interface CompiledMinV3 {
+    kind: 'min';
+    source: CompiledExpressionV3;
+}
+export interface CompiledMaxV3 {
+    kind: 'max';
+    source: CompiledExpressionV3;
+}
+export interface CompiledAverageV3 {
+    kind: 'average';
+    source: CompiledExpressionV3;
+}
+export interface CompiledForEachV3 {
+    kind: 'for-each';
+    source: CompiledExpressionV3;
+    loopVar: string;
+    emit: CompiledExpressionV3;
+}
+export interface CompiledListMapV3 {
+    kind: 'list-map';
+    source: CompiledExpressionV3;
+    loopVar: string;
+    mapBody: CompiledExpressionV3;
+}
+export interface CompiledFilterV3 {
+    kind: 'filter';
+    source: CompiledExpressionV3;
+    loopVar: string;
+    predicate: CompiledExpressionV3;
+}
+export interface CompiledPartitionByV3 {
+    kind: 'partition-by';
+    source: CompiledExpressionV3;
+    loopVar: string;
+    partitionKey: CompiledExpressionV3;
+}
+export interface CompiledDistinctByV3 {
+    kind: 'distinct-by';
+    source: CompiledExpressionV3;
+    loopVar: string;
+    distinctKey: CompiledExpressionV3;
+}

package/dist/transformations/v3/ExpressionEngineV3.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Evaluates a `CompiledExpressionV3` tree against an environment.
+ *
+ * Covers the full v3 Expression hierarchy. Aggregations are strict
+ * about element types — non-numeric elements in a Sum/Min/Max/Average
+ * raise a runtime error. Min/Max/Average on an empty list also error
+ * (per the ontology contract); Sum on empty returns 0; Count works
+ * regardless of element type.
+ *
+ * Property reads walk `statement[]` by canonical predicate URI via
+ * `UriHelpers`. Reference resolution during traversal goes through
+ * the shared `ReferenceResolver`.
+ */
+import { type Kanonak } from '@kanonak-protocol/sdk';
+import { type EntityUri } from '../../capabilities/UriHelpers.js';
+import { ReferenceResolver } from '../ReferenceResolver.js';
+import type { CompiledExpressionV3 } from './CompiledTransformationV3.js';
+/**
+ * Runtime representation of a Partition produced by the
+ * `PartitionBy` expression. Carries the partition key value plus
+ * the list of source elements that share that key.
+ *
+ * The engine surfaces Partitions as plain JS objects; PropertyRead
+ * special-cases this shape so authors can read `partition.key` and
+ * `partition.members` from inside a ForEach over the partition list.
+ */
+export interface RuntimePartitionV3 {
+    kind: 'Partition';
+    key: EnvValue;
+    members: Kanonak[];
+}
+export type EnvValue = string | number | boolean | Kanonak | Kanonak[] | EnvValue[] | RuntimePartitionV3 | EntityUri | unknown | undefined | null;
+export type Env = Map<string, EnvValue>;
+export declare class ExpressionEvalErrorV3 extends Error {
+}
+export declare class ExpressionEngineV3 {
+    private readonly resolver;
+    private readonly catalog;
+    constructor(resolver: ReferenceResolver, catalog: Kanonak[]);
+    evaluate(expr: CompiledExpressionV3, env: Env): Promise<EnvValue>;
+    /**
+     * Evaluate a source expression and coerce its result into a list.
+     * Single-valued results are wrapped in a single-element list so
+     * downstream operations don't have to special-case scalar sources
+     * (e.g. an aggregation over a property that happens to be
+     * single-valued for one instance and multi-valued for another).
+     */
+    private evaluateList;
+}

package/dist/transformations/v3/TransformationLoaderV3.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compiles a transformations@3.0.0 SubjectKanonak into a typed
+ * CompiledTransformationV3. Walks `statement[]` via the SDK's parsed
+ * object model — never re-parses YAML, never matches on alias
+ * prefixes. Property reads go through `UriHelpers`; type dispatch
+ * uses `hasType` against canonical `TX_V3` URIs.
+ *
+ * Throws `TransformationLoadErrorV3` with a breadcrumb path on the
+ * first shape violation.
+ */
+import { SubjectKanonak, type Kanonak } from '@kanonak-protocol/sdk';
+import type { CompiledTransformationV3 } from './CompiledTransformationV3.js';
+export declare class TransformationLoadErrorV3 extends Error {
+    readonly path: string;
+    constructor(message: string, path: string);
+}
+/**
+ * Top-level entry point. Determines whether the SubjectKanonak is an
+ * InstanceTransformation or SetTransformation by RDF type, then
+ * dispatches to the appropriate compiler.
+ */
+export declare function compileTransformationV3(transformation: SubjectKanonak, catalog: Kanonak[]): CompiledTransformationV3;

package/dist/transformations/v3/TransformationRunnerV3.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Runtime entry point for transformations@3.0.0.
+ *
+ * Two pipelines:
+ *
+ *   - InstanceTransformation: 1 input → 1 artifact. The runner filters
+ *     candidates by InputPattern, then evaluates `rule` and
+ *     `artifactName` once per candidate with `input` bound. Sort
+ *     order on the InputPattern affects the order of emitted
+ *     artifacts but doesn't change the cardinality.
+ *
+ *   - SetTransformation:
+ *       Without partitionBy: N candidates → 1 artifact, with `inputs`
+ *         bound to the entire matched (and optionally sorted) list.
+ *       With partitionBy: candidates are partitioned by the property
+ *         value; one artifact per partition, with `inputs` bound to
+ *         that partition's members and `key` bound to the partition
+ *         value. Candidates whose partition property is absent are
+ *         dropped (no group is created).
+ *
+ * Sort behavior:
+ *   - SortKey.byProperty is read off each candidate. Missing values
+ *     sort last (ascending) or first (descending). Lists or
+ *     references on the sort property are an authoring error caught
+ *     here at runtime.
+ *
+ * The runner does NOT touch the filesystem — writing is the
+ * deployment handler / CLI's job. Backends are version-agnostic and
+ * shared with any other transformation runtime.
+ */
+import { SubjectKanonak, type Kanonak, type IKanonakDocumentRepository, KanonakParser, KanonakObjectParser } from '@kanonak-protocol/sdk';
+import type { IDocumentAstBackend } from '../backends/IDocumentAstBackend.js';
+import { TransformationLoadErrorV3 } from './TransformationLoaderV3.js';
+import type { CompiledTransformationV3 } from './CompiledTransformationV3.js';
+export interface ArtifactV3 {
+    /** Filename stem (no directory, no extension). */
+    fileName: string;
+    /** OutputFormat local name this was rendered as. */
+    format: string;
+    /** Serialized bytes. */
+    content: string;
+    /** Provenance — which subject(s) drove this artifact. */
+    source: ArtifactProvenanceV3;
+}
+export type ArtifactProvenanceV3 = {
+    kind: 'instance';
+    sourceName: string;
+} | {
+    kind: 'set';
+    memberCount: number;
+    partitionKey?: string;
+};
+export interface FormatDescriptorV3 {
+    formatUri: string;
+    extension: string;
+}
+export declare const SUPPORTED_FORMATS_V3: Record<string, FormatDescriptorV3>;
+export interface RunInputV3 {
+    transformation: SubjectKanonak;
+    /** Candidate input subjects. Caller is responsible for subclass-aware selection. */
+    instances: SubjectKanonak[];
+    /** All loaded kanonaks for fragment lookup + reference resolution. */
+    allKanonaks: Kanonak[];
+    /**
+     * Optional kanonaks of the transformation's own package (where any
+     * ExpressionFragments live). Falls back to allKanonaks.
+     */
+    transformationKanonaks?: Kanonak[];
+    /** Repository for cross-package reference resolution at evaluation time. */
+    repository: IKanonakDocumentRepository;
+    parser: KanonakParser;
+    objectParser: KanonakObjectParser;
+    /** OutputFormat local name (e.g. `'markdown-with-frontmatter'`). */
+    outputFormat: string;
+}
+export declare class TransformationRunnerErrorV3 extends Error {
+}
+export declare class TransformationRunnerV3 {
+    private readonly backends;
+    constructor();
+    register(backend: IDocumentAstBackend): void;
+    run(input: RunInputV3): Promise<ArtifactV3[]>;
+    private runInstance;
+    private runSet;
+    private runSetSingle;
+    private runSetWithPartition;
+    private findBackend;
+}
+export { TransformationLoadErrorV3 };
+export type { CompiledTransformationV3 };

package/dist/transformations/v3/TransformationUriConstantsV3.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Hardcoded canonical URIs for the transformations@3.0.0 ontology.
+ *
+ * Versioned in the file path (`v3/`) and the symbol (`TX_V3`) so a
+ * future v4 ontology can ship a sibling `v4/TransformationUriConstantsV4.ts`
+ * and the runtime can dispatch by the resolved type's package version
+ * without forcing existing v3 transformations to upgrade.
+ *
+ * Per the typescript repo's CLAUDE.md rule 6, hardcoded URI constants
+ * are fine and expected — they are the ontology contract. String
+ * heuristics on aliases or suffixes are NOT.
+ */
+import type { EntityUri } from '../../capabilities/UriHelpers.js';
+export declare const TX_V3_PUB = "kanonak.org";
+export declare const TX_V3_PKG = "transformations";
+export declare const TX_V3_VERSION_MAJOR = 3;
+export declare const TX_V3: {
+    readonly Transformation: EntityUri;
+    readonly InstanceTransformation: EntityUri;
+    readonly SetTransformation: EntityUri;
+    readonly inputPattern: EntityUri;
+    readonly rule: EntityUri;
+    readonly artifactName: EntityUri;
+    readonly outputs: EntityUri;
+    readonly formatOverrides: EntityUri;
+    readonly partitionBy: EntityUri;
+    readonly InputPattern: EntityUri;
+    readonly matchesClass: EntityUri;
+    readonly requires: EntityUri;
+    readonly sortBy: EntityUri;
+    readonly SortKey: EntityUri;
+    readonly byProperty: EntityUri;
+    readonly order: EntityUri;
+    readonly SortOrder: EntityUri;
+    readonly ascending: EntityUri;
+    readonly descending: EntityUri;
+    readonly OutputFormat: EntityUri;
+    readonly backendUri: EntityUri;
+    readonly FormatOverride: EntityUri;
+    readonly formatTarget: EntityUri;
+    readonly metadataKeys: EntityUri;
+    readonly metadataRenames: EntityUri;
+    readonly trailingNewline: EntityUri;
+    readonly RenameEntry: EntityUri;
+    readonly fromKey: EntityUri;
+    readonly toKey: EntityUri;
+    readonly FMT_MARKDOWN_FRONTMATTER: EntityUri;
+    readonly FMT_PLAIN_MARKDOWN: EntityUri;
+    readonly FMT_TOML: EntityUri;
+    readonly FMT_JSON: EntityUri;
+    readonly FMT_HTML: EntityUri;
+    readonly FMT_SVG: EntityUri;
+    readonly Expression: EntityUri;
+    readonly ListSourcedExpression: EntityUri;
+    readonly ListAggregate: EntityUri;
+    readonly IteratingExpression: EntityUri;
+    readonly BuildAstNode: EntityUri;
+    readonly astClass: EntityUri;
+    readonly set: EntityUri;
+    readonly AstFieldBinding: EntityUri;
+    readonly field: EntityUri;
+    readonly bindValue: EntityUri;
+    readonly When: EntityUri;
+    readonly condition: EntityUri;
+    readonly thenBuild: EntityUri;
+    readonly elseBuild: EntityUri;
+    readonly Concat: EntityUri;
+    readonly parts: EntityUri;
+    readonly Fallback: EntityUri;
+    readonly primary: EntityUri;
+    readonly alternate: EntityUri;
+    readonly StringLiteral: EntityUri;
+    readonly stringLiteral: EntityUri;
+    readonly IntegerLiteral: EntityUri;
+    readonly integerLiteral: EntityUri;
+    readonly DecimalLiteral: EntityUri;
+    readonly decimalLiteral: EntityUri;
+    readonly BooleanLiteral: EntityUri;
+    readonly booleanLiteral: EntityUri;
+    readonly VarRef: EntityUri;
+    readonly varName: EntityUri;
+    readonly PropertyRead: EntityUri;
+    readonly readSource: EntityUri;
+    readonly readProp: EntityUri;
+    readonly Traverse: EntityUri;
+    readonly traverseSource: EntityUri;
+    readonly through: EntityUri;
+    readonly step: EntityUri;
+    readonly UriName: EntityUri;
+    readonly uriNameOf: EntityUri;
+    readonly UriLiteral: EntityUri;
+    readonly refTo: EntityUri;
+    readonly DisplayLabel: EntityUri;
+    readonly labelTarget: EntityUri;
+    readonly labelSource: EntityUri;
+    readonly ResolveRef: EntityUri;
+    readonly resolveSource: EntityUri;
+    readonly Normalize: EntityUri;
+    readonly normSource: EntityUri;
+    readonly normKind: EntityUri;
+    readonly NormalizeKind: EntityUri;
+    readonly NORM_TRIM_END: EntityUri;
+    readonly IsSet: EntityUri;
+    readonly checkExpr: EntityUri;
+    readonly ExpressionFragment: EntityUri;
+    readonly body: EntityUri;
+    readonly CallFragment: EntityUri;
+    readonly fragmentRef: EntityUri;
+    readonly source: EntityUri;
+    readonly Join: EntityUri;
+    readonly separator: EntityUri;
+    readonly Count: EntityUri;
+    readonly Sum: EntityUri;
+    readonly Min: EntityUri;
+    readonly Max: EntityUri;
+    readonly Average: EntityUri;
+    readonly loopVar: EntityUri;
+    readonly ForEach: EntityUri;
+    readonly emit: EntityUri;
+    readonly ListMap: EntityUri;
+    readonly mapBody: EntityUri;
+    readonly Filter: EntityUri;
+    readonly predicate: EntityUri;
+    readonly PartitionBy: EntityUri;
+    readonly partitionKey: EntityUri;
+    readonly DistinctBy: EntityUri;
+    readonly distinctKey: EntityUri;
+    readonly Partition: EntityUri;
+    readonly key: EntityUri;
+    readonly members: EntityUri;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanonak-protocol/cli",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Kanonak Protocol CLI - Validate and resolve Kanonak ontology packages",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,8 +34,8 @@
     "semantic-web"
   ],
   "dependencies": {
-    "@kanonak-protocol/sdk": "^2.5.0",
-    "@kanonak-protocol/types": "^2.5.0",
+    "@kanonak-protocol/sdk": "^3.0.0",
+    "@kanonak-protocol/types": "^3.0.0",
     "commander": "^13.0.0",
     "js-yaml": "^4.1.1"
   },