@blackcatinformatics/purrdf 0.5.0 → 0.7.0

package/README.md

@@ -76,6 +76,51 @@ const names = engine.select(
 console.log(names.rows.take(0)?.message.value);
 ```
 
+## Graph, tabular, and research-object projection archives
+
+Projection and lift run entirely in memory through the native Rust engine. The
+caller supplies strict profile-tagged JSON; PurRDF does not fabricate vocabulary,
+identity, or resource limits.
+
+```js
+import { Dataset, liftProjection, ready } from "@blackcatinformatics/purrdf";
+
+await ready();
+const config = JSON.stringify({
+  profile: "lpg-csv",
+  config: {
+    rdf_type: "https://example.org/type",
+    limits: {
+      max_artifacts: 16,
+      max_artifact_bytes: 1_000_000,
+      max_total_bytes: 4_000_000,
+      max_archive_bytes: 5_000_000,
+      max_term_depth: 16,
+    },
+    max_records: 1_000,
+  },
+});
+const dataset = Dataset.parse(
+  "@prefix ex: <https://example.org/> . ex:alice ex:knows ex:bob .",
+  "turtle",
+);
+const projected = dataset.project("lpg-csv", config);
+const lifted = liftProjection(projected.archive, "lpg-csv", config);
+const roundTrip = lifted.takeDataset();
+console.log(roundTrip?.size, JSON.parse(projected.lossLedgerJson));
+```
+
+`lpg-csv`, `neo4j-csv`, `open-cypher`, `graphml`, `csvw-exact`,
+`croissant-1.1`, `ro-crate-1.3`, `datacite-4.6`, `dcat-3`, and
+`frictionless-data-package-1` are bidirectional. `obo-graphs` and `skos` are
+write-only, loss-ledgered views and are excluded from the `LiftProfile`
+TypeScript union. Research-object contexts, vocabularies, identities, and
+profiles are mandatory caller configuration. Archives are canonical
+deterministic USTAR bytes. Package/lift objects own wasm memory; call `free()`
+when finished, and remember that `takeDataset()` transfers its dataset exactly
+once. A runnable Node example is
+[`projection-roundtrip.mjs`](https://github.com/Blackcat-Informatics/purrdf/blob/main/crates/rdf-wasm/js/examples/projection-roundtrip.mjs).
+
 ## API surface
 
 - `ready(bytesOrUrl?)` — one-time async wasm instantiation.
@@ -87,6 +132,9 @@ console.log(names.rows.take(0)?.message.value);
   Formats: `turtle`, `ntriples`, `nquads`, `trig`, `rdfxml` (`serialize` also `jsonld`).
 - `Dataset.canonicalize()` / `Dataset.isomorphic(other)` — RDFC-1.0 canonical N-Quads
   and RDF graph-identity (isomorphism under blank-node relabeling).
+- `Dataset.project(profile, configJson)` / `liftProjection(archive, profile,
+  configJson)` — canonical graph/tabular/research-object USTAR carriers with structured,
+  always-computed loss-ledger JSON.
 - `Dataset.visualModel(options?)` / `visualExport(options?)` /
   `visualSvg(options?)` — the renderer-neutral RDF 1.2 model, complete semantic
   scene and deterministic geometry, or self-contained SVG paired with that export.

package/index.d.ts

@@ -378,6 +378,7 @@ export class Dataset implements Iterable<Quad> {
     graph?: Term | null,
   ): Dataset;
   quads(): Quad[];
+  project(profile: ProjectionProfile, configJson: string): ProjectionPackage;
   visualModel(options?: VisualizationOptions | null): VisualModel;
   visualExport(options?: VisualizationOptions | null): VisualExport;
   visualSvg(options?: VisualizationOptions | null): VisualSvgDocument;
@@ -390,6 +391,49 @@ export class Dataset implements Iterable<Quad> {
   free(): void;
 }
 
+export type ProjectionProfile =
+  | "lpg-csv"
+  | "neo4j-csv"
+  | "open-cypher"
+  | "graphml"
+  | "csvw-exact"
+  | "obo-graphs"
+  | "skos"
+  | "croissant-1.1"
+  | "ro-crate-1.3"
+  | "datacite-4.6"
+  | "dcat-3"
+  | "frictionless-data-package-1";
+
+export type LiftProfile = Exclude<ProjectionProfile, "obo-graphs" | "skos">;
+
+export interface ProjectionLossLedger {
+  schema_version: 1;
+  losses: Array<{
+    code: string;
+    from: string;
+    to: string;
+    intentional: boolean;
+    note: string;
+    location?: string;
+  }>;
+}
+
+export class ProjectionPackage {
+  private constructor();
+  readonly profile: ProjectionProfile;
+  readonly archive: Uint8Array;
+  readonly lossLedgerJson: string;
+  free(): void;
+}
+
+export class ProjectionLift {
+  private constructor();
+  readonly lossLedgerJson: string;
+  takeDataset(): Dataset | undefined;
+  free(): void;
+}
+
 export class QueryEngine {
   constructor();
   query(dataset: Dataset, sparql: string, options?: QueryOptions | null): QueryResult;
@@ -414,6 +458,11 @@ export function datasetToStream(dataset: Dataset): AsyncIterableIterator<Quad>;
 export function streamToDataset(
   quadStream: AsyncIterable<Quad> | Iterable<Quad>,
 ): Promise<Dataset>;
+export function liftProjection(
+  archive: Uint8Array,
+  profile: LiftProfile,
+  configJson: string,
+): ProjectionLift;
 export function shaclEntail(shapesTtl: string, dataNt: string): string;
 export function shaclValidateToSarif(shapesTtl: string, dataNt: string): string;
 export function version(): string;

package/index.mjs

@@ -21,6 +21,9 @@
 import init, {
   DataFactory,
   Dataset,
+  liftProjection,
+  ProjectionLift,
+  ProjectionPackage,
   Quad,
   QueryEngine,
   shaclEntail,
@@ -330,6 +333,9 @@ export async function streamToDataset(quadStream) {
 export {
   DataFactory,
   Dataset,
+  liftProjection,
+  ProjectionLift,
+  ProjectionPackage,
   Quad,
   QueryEngine,
   shaclEntail,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackcatinformatics/purrdf",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A wasm32, in-memory RDF 1.2 engine with an idiomatic RDF/JS (DataFactory/Dataset/Stream) API. Quoted-triple terms and directional literals included.",
   "type": "module",
   "license": "MIT OR Apache-2.0",
@@ -43,6 +43,7 @@
     "typecheck": "tsc -p tsconfig.types.json"
   },
   "devDependencies": {
+    "graphql": "16.14.0",
     "typescript": "7.0.2"
   },
   "engines": {

package/pkg/purrdf_wasm.d.ts

@@ -123,10 +123,15 @@ export class Dataset {
     /**
      * `parse(input, format, base?)` → a dataset of the parsed quads.
      *
-     * `format` is a media type or short name (turtle/ntriples/nquads/trig/rdfxml).
+     * `format` is a media type or short name
+     * (turtle/ntriples/nquads/trig/rdfxml/jsonld/yamlld).
      * Ill-typed literals are preserved verbatim (RDFLib parity), not rejected.
      */
     static parse(input: string, format: string, base?: string | null): Dataset;
+    /**
+     * Project this dataset into a deterministic graph, tabular, or research-object USTAR package.
+     */
+    project(profile: string, config_json: string): ProjectionPackage;
     /**
      * `quads()` → every effective quad, as a JS array.
      */
@@ -143,10 +148,13 @@ export class Dataset {
     /**
      * `serialize(format)` → the dataset rendered in `format` (a UTF-8 string).
      *
-     * Formats: `turtle` / `ntriples` / `nquads` / `trig` / `rdfxml` (their media types
-     * too) plus `jsonld` (JSON-LD-star). Note: a quoted-triple term appearing as a quad
-     * object currently round-trips only through N-Quads (a serializer limitation for
-     * the other text formats).
+     * Formats: `turtle` / `ntriples` / `nquads` / `trig` / `rdfxml` / `jsonld`
+     * (JSON-LD-star) / `yamlld` (YAML-LD-star), and their media types — all resolved
+     * through the one core registry.
+     *
+     * Object-position quoted-triple terms (RDF-1.2 triple terms) are preserved
+     * through N-Quads, JSON-LD, and YAML-LD; the other text syntaxes (Turtle,
+     * N-Triples, TriG, RDF/XML) flatten them.
      */
     serialize(format: string): string;
     /**
@@ -167,6 +175,44 @@ export class Dataset {
     readonly size: number;
 }
 
+/**
+ * Result of lifting a strict carrier package into an in-memory RDF dataset.
+ */
+export class ProjectionLift {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Move the lifted dataset out of this result. The dataset can be taken once.
+     */
+    takeDataset(): Dataset | undefined;
+    /**
+     * Canonical, versioned runtime loss-ledger JSON.
+     */
+    readonly lossLedgerJson: string;
+}
+
+/**
+ * A deterministic USTAR projection package and its canonical runtime ledger.
+ */
+export class ProjectionPackage {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Canonical deterministic USTAR bytes.
+     */
+    readonly archive: Uint8Array;
+    /**
+     * Canonical, versioned runtime loss-ledger JSON.
+     */
+    readonly lossLedgerJson: string;
+    /**
+     * Stable carrier profile name.
+     */
+    readonly profile: string;
+}
+
 /**
  * An RDF/JS [Quad](https://rdf.js.org/data-model-spec/#quad-interface) — a statement
  * `(subject, predicate, object, graph)` with `termType: "Quad"`.
@@ -406,6 +452,11 @@ export class Term {
     readonly value: string;
 }
 
+/**
+ * Lift a strict bidirectional USTAR package into an in-memory RDF dataset.
+ */
+export function liftProjection(archive: Uint8Array, profile: string, config_json: string): ProjectionLift;
+
 /**
  * `shaclEntail(shapesTtl, dataNt)` → the materialized dataset as an N-Triples
  * string (the base graph plus every inferred triple).
@@ -437,6 +488,8 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_datafactory_free: (a: number, b: number) => void;
     readonly __wbg_dataset_free: (a: number, b: number) => void;
+    readonly __wbg_projectionlift_free: (a: number, b: number) => void;
+    readonly __wbg_projectionpackage_free: (a: number, b: number) => void;
     readonly __wbg_quad_free: (a: number, b: number) => void;
     readonly __wbg_queryengine_free: (a: number, b: number) => void;
     readonly __wbg_queryresult_free: (a: number, b: number) => void;
@@ -464,6 +517,7 @@ export interface InitOutput {
     readonly dataset_match: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly dataset_new: (a: number) => void;
     readonly dataset_parse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly dataset_project: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly dataset_quads: (a: number, b: number) => void;
     readonly dataset_query: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly dataset_serialize: (a: number, b: number, c: number, d: number) => void;
@@ -471,6 +525,12 @@ export interface InitOutput {
     readonly dataset_visualExportJson: (a: number, b: number, c: number, d: number) => void;
     readonly dataset_visualModelJson: (a: number, b: number, c: number, d: number) => void;
     readonly dataset_visualSvgJson: (a: number, b: number, c: number, d: number) => void;
+    readonly liftProjection: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly projectionlift_lossLedgerJson: (a: number, b: number) => void;
+    readonly projectionlift_takeDataset: (a: number) => number;
+    readonly projectionpackage_archive: (a: number, b: number) => void;
+    readonly projectionpackage_lossLedgerJson: (a: number, b: number) => void;
+    readonly projectionpackage_profile: (a: number, b: number) => void;
     readonly quad_asTerm: (a: number, b: number) => void;
     readonly quad_equals: (a: number, b: number) => number;
     readonly quad_graph: (a: number) => number;

package/pkg/purrdf_wasm.js

@@ -425,7 +425,8 @@ export class Dataset {
     /**
      * `parse(input, format, base?)` → a dataset of the parsed quads.
      *
-     * `format` is a media type or short name (turtle/ntriples/nquads/trig/rdfxml).
+     * `format` is a media type or short name
+     * (turtle/ntriples/nquads/trig/rdfxml/jsonld/yamlld).
      * Ill-typed literals are preserved verbatim (RDFLib parity), not rejected.
      * @param {string} input
      * @param {string} format
@@ -453,6 +454,31 @@ export class Dataset {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Project this dataset into a deterministic graph, tabular, or research-object USTAR package.
+     * @param {string} profile
+     * @param {string} config_json
+     * @returns {ProjectionPackage}
+     */
+    project(profile, config_json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(profile, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(config_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.dataset_project(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ProjectionPackage.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * `quads()` → every effective quad, as a JS array.
      * @returns {Quad[]}
@@ -517,10 +543,13 @@ export class Dataset {
     /**
      * `serialize(format)` → the dataset rendered in `format` (a UTF-8 string).
      *
-     * Formats: `turtle` / `ntriples` / `nquads` / `trig` / `rdfxml` (their media types
-     * too) plus `jsonld` (JSON-LD-star). Note: a quoted-triple term appearing as a quad
-     * object currently round-trips only through N-Quads (a serializer limitation for
-     * the other text formats).
+     * Formats: `turtle` / `ntriples` / `nquads` / `trig` / `rdfxml` / `jsonld`
+     * (JSON-LD-star) / `yamlld` (YAML-LD-star), and their media types — all resolved
+     * through the one core registry.
+     *
+     * Object-position quoted-triple terms (RDF-1.2 triple terms) are preserved
+     * through N-Quads, JSON-LD, and YAML-LD; the other text syntaxes (Turtle,
+     * N-Triples, TriG, RDF/XML) flatten them.
      * @param {string} format
      * @returns {string}
      */
@@ -654,6 +683,137 @@ export class Dataset {
 }
 if (Symbol.dispose) Dataset.prototype[Symbol.dispose] = Dataset.prototype.free;
 
+/**
+ * Result of lifting a strict carrier package into an in-memory RDF dataset.
+ */
+export class ProjectionLift {
+    static __wrap(ptr) {
+        const obj = Object.create(ProjectionLift.prototype);
+        obj.__wbg_ptr = ptr;
+        ProjectionLiftFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProjectionLiftFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_projectionlift_free(ptr, 0);
+    }
+    /**
+     * Canonical, versioned runtime loss-ledger JSON.
+     * @returns {string}
+     */
+    get lossLedgerJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.projectionlift_lossLedgerJson(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Move the lifted dataset out of this result. The dataset can be taken once.
+     * @returns {Dataset | undefined}
+     */
+    takeDataset() {
+        const ret = wasm.projectionlift_takeDataset(this.__wbg_ptr);
+        return ret === 0 ? undefined : Dataset.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ProjectionLift.prototype[Symbol.dispose] = ProjectionLift.prototype.free;
+
+/**
+ * A deterministic USTAR projection package and its canonical runtime ledger.
+ */
+export class ProjectionPackage {
+    static __wrap(ptr) {
+        const obj = Object.create(ProjectionPackage.prototype);
+        obj.__wbg_ptr = ptr;
+        ProjectionPackageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProjectionPackageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_projectionpackage_free(ptr, 0);
+    }
+    /**
+     * Canonical deterministic USTAR bytes.
+     * @returns {Uint8Array}
+     */
+    get archive() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.projectionpackage_archive(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Canonical, versioned runtime loss-ledger JSON.
+     * @returns {string}
+     */
+    get lossLedgerJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.projectionpackage_lossLedgerJson(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Stable carrier profile name.
+     * @returns {string}
+     */
+    get profile() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.projectionpackage_profile(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ProjectionPackage.prototype[Symbol.dispose] = ProjectionPackage.prototype.free;
+
 /**
  * An RDF/JS [Quad](https://rdf.js.org/data-model-spec/#quad-interface) — a statement
  * `(subject, predicate, object, graph)` with `termType: "Quad"`.
@@ -1448,6 +1608,35 @@ export class Term {
 }
 if (Symbol.dispose) Term.prototype[Symbol.dispose] = Term.prototype.free;
 
+/**
+ * Lift a strict bidirectional USTAR package into an in-memory RDF dataset.
+ * @param {Uint8Array} archive
+ * @param {string} profile
+ * @param {string} config_json
+ * @returns {ProjectionLift}
+ */
+export function liftProjection(archive, profile, config_json) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(archive, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(profile, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(config_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.liftProjection(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return ProjectionLift.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * `shaclEntail(shapesTtl, dataNt)` → the materialized dataset as an N-Triples
  * string (the base graph plus every inferred triple).
@@ -1591,6 +1780,12 @@ const DataFactoryFinalization = (typeof FinalizationRegistry === 'undefined')
 const DatasetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dataset_free(ptr, 1));
+const ProjectionLiftFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_projectionlift_free(ptr, 1));
+const ProjectionPackageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_projectionpackage_free(ptr, 1));
 const QuadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_quad_free(ptr, 1));
@@ -1644,6 +1839,11 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -1675,6 +1875,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/pkg/purrdf_wasm_bg.wasm.d.ts

@@ -3,6 +3,8 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_datafactory_free: (a: number, b: number) => void;
 export const __wbg_dataset_free: (a: number, b: number) => void;
+export const __wbg_projectionlift_free: (a: number, b: number) => void;
+export const __wbg_projectionpackage_free: (a: number, b: number) => void;
 export const __wbg_quad_free: (a: number, b: number) => void;
 export const __wbg_queryengine_free: (a: number, b: number) => void;
 export const __wbg_queryresult_free: (a: number, b: number) => void;
@@ -30,6 +32,7 @@ export const dataset_isomorphic: (a: number, b: number, c: number) => void;
 export const dataset_match: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const dataset_new: (a: number) => void;
 export const dataset_parse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const dataset_project: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const dataset_quads: (a: number, b: number) => void;
 export const dataset_query: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const dataset_serialize: (a: number, b: number, c: number, d: number) => void;
@@ -37,6 +40,12 @@ export const dataset_size: (a: number) => number;
 export const dataset_visualExportJson: (a: number, b: number, c: number, d: number) => void;
 export const dataset_visualModelJson: (a: number, b: number, c: number, d: number) => void;
 export const dataset_visualSvgJson: (a: number, b: number, c: number, d: number) => void;
+export const liftProjection: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const projectionlift_lossLedgerJson: (a: number, b: number) => void;
+export const projectionlift_takeDataset: (a: number) => number;
+export const projectionpackage_archive: (a: number, b: number) => void;
+export const projectionpackage_lossLedgerJson: (a: number, b: number) => void;
+export const projectionpackage_profile: (a: number, b: number) => void;
 export const quad_asTerm: (a: number, b: number) => void;
 export const quad_equals: (a: number, b: number) => number;
 export const quad_graph: (a: number) => number;