@sixb/core 0.1.20 → 0.1.22

package/dist/artifacts/publish/index.js

@@ -0,0 +1,76 @@
+// @bun
+import"../../chunk-h3pbv7n8.js";
+import"../../chunk-vhbw5sqm.js";
+import"../../chunk-zbc929zg.js";
+import"../../chunk-6eqsgvxk.js";
+import"../../chunk-yc9ners4.js";
+import"../../chunk-4y26vs3v.js";
+import"../../chunk-rap5w0x0.js";
+import"../../chunk-wkv3h3q7.js";
+import"../../chunk-65pyhyas.js";
+import"../../chunk-73v685wb.js";
+import"../../chunk-bab05bhg.js";
+import"../../chunk-cdk3egjj.js";
+import"../../chunk-zrvhsq7f.js";
+import"../../chunk-5grk14e5.js";
+import {
+  ARTIFACT_LIMITS2
+} from "../../chunk-hz5d43gn.js";
+import {
+  isArtifactId2
+} from "../../chunk-3fqxbn31.js";
+import {
+  artifactQueryName2
+} from "../../chunk-waqk73p1.js";
+import"../../chunk-x0v3jd47.js";
+import"../../chunk-6rrtzea3.js";
+import"../../chunk-mbsbxarb.js";
+import"../../chunk-c0vk1djt.js";
+import"../../chunk-pdt5cw8z.js";
+import"../../chunk-tdxfsg1c.js";
+import"../../chunk-nydf3dbe.js";
+import"../../chunk-0xmt5p5y.js";
+import"../../chunk-4ymrcdbm.js";
+import"../../chunk-h89wz928.js";
+import"../../chunk-hwarjrgf.js";
+import"../../chunk-fe8zwt8b.js";
+import"../../chunk-gfdh9kqa.js";
+import"../../chunk-cwdzcv37.js";
+import"../../chunk-eptrvnby.js";
+import"../../chunk-cswhawa2.js";
+import"../../chunk-ezne9wc9.js";
+import"../../chunk-hqsp2sx4.js";
+import"../../chunk-2adz0h75.js";
+import"../../chunk-mmagke4x.js";
+import"../../chunk-hn2r7z41.js";
+import"../../chunk-g663fahq.js";
+import"../../chunk-jmfet9r4.js";
+import"../../chunk-qf954wje.js";
+import"../../chunk-efmm01gj.js";
+import"../../chunk-7z5p905k.js";
+import"../../chunk-qx00vjrj.js";
+import {
+  publishArtifact2,
+  prepareArtifactVersion2,
+  storeArtifactVersion2,
+  artifactVersionWarnings2,
+  artifactAccessRule2,
+  artifactQueryChecker2
+} from "../../chunk-qhqgp4jf.js";
+import"../../chunk-fm62y49k.js";
+import"../../chunk-pgrf64hp.js";
+import"../../chunk-6n69k945.js";
+import"../../chunk-a3faa34j.js";
+export {
+  ARTIFACT_LIMITS2 as ARTIFACT_LIMITS,
+  artifactAccessRule2 as artifactAccessRule,
+  artifactQueryChecker2 as artifactQueryChecker,
+  artifactQueryName2 as artifactQueryName,
+  artifactVersionWarnings2 as artifactVersionWarnings,
+  isArtifactId2 as isArtifactId,
+  prepareArtifactVersion2 as prepareArtifactVersion,
+  publishArtifact2 as publishArtifact,
+  storeArtifactVersion2 as storeArtifactVersion
+};
+
+//# debugId=F3980B58FEDAC92E64756E2164756E21

package/dist/{chunk-7n30ybym.js.map → artifacts/publish/index.js.map}

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "92619866D6E6BE9764756E2164756E21",
+  "debugId": "F3980B58FEDAC92E64756E2164756E21",
   "names": []
 }

package/dist/artifacts/publish/publish.d.ts

@@ -0,0 +1,84 @@
+import type { Principal } from "../../auth";
+import type { ArtifactFile, ArtifactOrigin, ArtifactRecord, ArtifactStorage, ArtifactVersionInput, ArtifactVersionRecord, PublishedArtifactVersion } from "../../storage/artifacts/types";
+import { type ArtifactAccess } from "../access";
+import type { ArtifactKind } from "../kinds";
+import type { ArtifactWarning } from "../warnings";
+import { type ArtifactBlobStorage } from "./files";
+import { type ArtifactQueryChecker } from "./queries";
+export interface PublishArtifactContext {
+    readonly projectId: string;
+    readonly storage: ArtifactStorage;
+    readonly blobStorage: ArtifactBlobStorage;
+}
+export interface PublishArtifactInput {
+    /** Publishes the next version of this artifact; without it, a new artifact is created. */
+    readonly artifactId?: string;
+    readonly kind: ArtifactKind;
+    readonly title: string;
+    readonly files: readonly ArtifactFile[];
+    /** Publishes the version, and owns the artifact when this creates it unless `owner` says. */
+    readonly author: Principal;
+    /** Owns the artifact when this creates it: a conversation's owner, for an Agent turn in it. */
+    readonly owner?: Principal;
+    /**
+     * Whether an address in the version may name this artifact: one the author can read. Defaults to
+     * the author's own artifacts.
+     */
+    readonly readable?: (artifact: ArtifactRecord) => Promise<boolean>;
+    /**
+     * Checks each of the version's queries as the author, so none reads what they cannot. Without
+     * it, a version that holds a query is refused.
+     */
+    readonly checkQuery?: ArtifactQueryChecker;
+    readonly origin?: ArtifactOrigin;
+    /** The version this one was made from: publishing fails with `artifact_moved` past it. */
+    readonly baseVersion?: number;
+}
+/**
+ * What the author may do with the artifact a version is published to, as the access rule's
+ * `publishAccess` answers it from where the version is stored: a transaction's storage, for a
+ * caller that stores in one. Storing refuses `none` with `not_shared` and `read` with `read_only`.
+ */
+export type PublishAccess = (artifact: ArtifactRecord) => Promise<ArtifactAccess>;
+export interface PublishedArtifact {
+    readonly artifact: ArtifactRecord;
+    readonly version: ArtifactVersionRecord;
+    readonly warnings: readonly ArtifactWarning[];
+}
+/** A version checked against its kind and with its addresses resolved, ready to store. */
+export interface PreparedArtifactVersion {
+    readonly artifactId?: string;
+    readonly baseVersion?: number;
+    readonly kind: ArtifactKind;
+    /** Owns the artifact when this version creates it. */
+    readonly owner: Principal;
+    readonly readable: (artifact: ArtifactRecord) => Promise<boolean>;
+    readonly version: ArtifactVersionInput;
+    /** What its kind's check found worth fixing in a version it accepts. */
+    readonly warnings: readonly ArtifactWarning[];
+}
+/**
+ * Validates a version against its kind and stores it. Who may publish is the caller's decision:
+ * this checks only what the version holds.
+ */
+export declare function publishArtifact(context: PublishArtifactContext, input: PublishArtifactInput, access: PublishAccess): Promise<PublishedArtifact>;
+/**
+ * Everything publishing checks before it stores: the title, the files, the theme, every query, run
+ * once as the author, the kind's own format, and every address, resolved against what the author
+ * can read. It reads the files back and parses them, so a caller that stores inside a
+ * transaction prepares outside it.
+ */
+export declare function prepareArtifactVersion(context: PublishArtifactContext, input: PublishArtifactInput): Promise<PreparedArtifactVersion>;
+/**
+ * Stores a prepared version: the next one of its artifact, or the first of a new one. The next
+ * version is refused unless `access` says its author may update the artifact: a caller that stores
+ * inside a transaction answers it from there, so the check and the write see the same artifact.
+ */
+export declare function storeArtifactVersion(context: PublishArtifactContext, prepared: PreparedArtifactVersion, access: PublishAccess): Promise<PublishedArtifactVersion>;
+/**
+ * What is worth fixing in a stored version: what its kind's check found, then what it breaks in
+ * other artifacts that show it. A first version breaks nothing: no other artifact could name it
+ * yet. The version is stored by now, so a failed check only loses those warnings.
+ */
+export declare function artifactVersionWarnings(context: PublishArtifactContext, prepared: PreparedArtifactVersion, stored: PublishedArtifactVersion): Promise<readonly ArtifactWarning[]>;
+//# sourceMappingURL=publish.d.ts.map

package/dist/artifacts/publish/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../src/artifacts/publish/publish.ts"],"names":[],"mappings":"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"}

package/dist/artifacts/publish/queries.d.ts

@@ -0,0 +1,33 @@
+import type { SixbRuntimeContext } from "../../runtime/types";
+import type { ArtifactFile } from "../../storage/artifacts/types";
+import type { ArtifactKind } from "../kinds";
+import { type ArtifactQuery, type CheckedArtifactQuery } from "../queries";
+import { type ArtifactBlobStorage } from "./files";
+/**
+ * Admits a query as the version's author: it throws what running it as them would throw, and
+ * refuses one that would return what they cannot read; it returns what the query returns and what
+ * its rows hold as they see them. A version is refused when its author could not run one of its
+ * queries, so a query never reads what whoever wrote it cannot. Each reader still runs it with
+ * their own rights.
+ */
+export type ArtifactQueryChecker = (query: ArtifactQuery) => Promise<CheckedArtifactQuery>;
+/**
+ * The checker for the runtime's caller. Running the query once, as cheaply as its kind allows,
+ * is the check: validation against the ontology, `can.view` on every type it reads, clearance for
+ * every marked property it filters, sorts or facets on, and the caller's share scope all apply
+ * there, as they do when it is read.
+ *
+ * What the rows carry is checked after: a read leaves out a marked property its reader is not
+ * cleared for, and the member profiles of a reader who may not view them, so running the query
+ * admits one that returns them. A reader's rows reach the page's code, which its author wrote, so
+ * the query may return only what the author can read. Facets return counts, never a property.
+ */
+export declare function createArtifactQueryChecker(runtime: Pick<SixbRuntimeContext, "objectReader" | "ontology" | "projectId" | "runtimeAuthorization" | "authorization">): ArtifactQueryChecker;
+/**
+ * Checks the `queries/` files of a version: their names and number, their shape, then each one as
+ * its author through `checker`, and returns what each check learned by query name, for the kind's
+ * own check. Fails closed: a version that holds a query is refused without one. A file artifact is
+ * delivered as it is, so its one file is never read as a query.
+ */
+export declare function checkArtifactQueries(blobStorage: ArtifactBlobStorage, kind: ArtifactKind, files: readonly ArtifactFile[], checker: ArtifactQueryChecker | undefined): Promise<ReadonlyMap<string, CheckedArtifactQuery>>;
+//# sourceMappingURL=queries.d.ts.map

package/dist/artifacts/publish/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/artifacts/publish/queries.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,OAAO,EAGL,KAAK,aAAa,EAElB,KAAK,oBAAoB,EAE1B,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,SAAS,CAAA;AAErF;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAA;AAE1F;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,IAAI,CACX,kBAAkB,EAClB,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,sBAAsB,GAAG,eAAe,CACrF,GACA,oBAAoB,CAmBtB;AAyKD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,EAAE,oBAAoB,GAAG,SAAS,GACxC,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CA+CpD"}

package/dist/artifacts/publish/references.d.ts

@@ -0,0 +1,30 @@
+import { type Principal } from "../../auth";
+import type { ArtifactRecord, ArtifactStorage, ArtifactVersionRecord } from "../../storage/artifacts/types";
+import type { ArtifactReference } from "../references";
+import type { ArtifactWarning } from "../warnings";
+/** An address a validator found in a version, before it is resolved. */
+export type FoundReference = Omit<ArtifactReference, "resolvedVersion">;
+interface ReferenceContext {
+    readonly projectId: string;
+    readonly storage: ArtifactStorage;
+    /** Whether an address may name this artifact: one whoever publishes can read. */
+    readonly readable: (artifact: ArtifactRecord) => Promise<boolean>;
+    /** The artifact being published, which an address may not name. */
+    readonly artifactId?: string;
+}
+/**
+ * Resolves every address a version uses against what its author can read, recording the version
+ * each one resolved to. An address that resolves to nothing refuses the version, saying where it
+ * is and what the target has instead.
+ */
+export declare function resolveReferences(context: ReferenceContext, found: readonly FoundReference[]): Promise<ArtifactReference[]>;
+/**
+ * The artifacts a new version breaks: each one whose latest version follows this artifact's latest
+ * and names something this version no longer has. Only artifacts the author can read are named,
+ * and only those the version breaks are checked: most dependents cost no read.
+ */
+export declare function brokenDependents(context: ReferenceContext, artifact: ArtifactRecord, version: ArtifactVersionRecord): Promise<ArtifactWarning[]>;
+/** What its author reads when nothing else is said: their own artifacts, or all for system code. */
+export declare function ownArtifacts(author: Principal): (artifact: ArtifactRecord) => Promise<boolean>;
+export {};
+//# sourceMappingURL=references.d.ts.map

package/dist/artifacts/publish/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../src/artifacts/publish/references.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,qBAAqB,EACtB,MAAM,+BAA+B,CAAA;AAGtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAEtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAGlD,wEAAwE;AACxE,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAA;AAEvE,UAAU,gBAAgB;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACjE,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,SAAS,cAAc,EAAE,GAC/B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAuD9B;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,eAAe,EAAE,CAAC,CA8B5B;AAED,oGAAoG;AACpG,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAE9F"}

package/dist/artifacts/publish/validate/canvas.d.ts

@@ -0,0 +1,18 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { CanvasOutline } from "../../outline";
+import type { ArtifactWarning } from "../../warnings";
+import { type ArtifactBlobStorage } from "../files";
+import type { FoundReference } from "../references";
+/**
+ * Reads a canvas: `canvas.json`, then each board's HTML, which must be one of the version's files.
+ * The addresses its embeds show and its boards use are returned to resolve, each at its item's id.
+ * Boards that overlap, and notes or text drawn over a board, are warnings: the reader sees a page
+ * covered.
+ */
+export declare function validateCanvas(blobStorage: ArtifactBlobStorage, files: readonly ArtifactFile[]): Promise<{
+    readonly entry: string;
+    readonly outline: CanvasOutline;
+    readonly references: readonly FoundReference[];
+    readonly warnings: readonly ArtifactWarning[];
+}>;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/artifacts/publish/validate/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/canvas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAGpE,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,eAAe,CAAA;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,UAAU,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGnD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,OAAO,CAAC;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;CAC9C,CAAC,CAmDD"}

package/dist/artifacts/publish/validate/document.d.ts

@@ -0,0 +1,17 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import { type DocumentOutline } from "../../outline";
+import { type ArtifactBlobStorage } from "../files";
+import type { FoundReference } from "../references";
+/** The file a document renders from. */
+export declare const DOCUMENT_ENTRY = "document.md";
+/**
+ * Reads a document's Markdown: its headings become the outline, and every image must be a file in
+ * the version or an `artifact:` address, so the document renders the same wherever it is opened.
+ * The addresses it shows and links to are returned with the section each sits in, to resolve.
+ */
+export declare function validateDocument(blobStorage: ArtifactBlobStorage, files: readonly ArtifactFile[]): Promise<{
+    readonly entry: string;
+    readonly outline: DocumentOutline;
+    readonly references: readonly FoundReference[];
+}>;
+//# sourceMappingURL=document.d.ts.map

package/dist/artifacts/publish/validate/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/document.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAIpE,OAAO,EAA8C,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAChG,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,UAAU,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,wCAAwC;AACxC,eAAO,MAAM,cAAc,gBAAgB,CAAA;AAE3C;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,OAAO,CAAC;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;CAC/C,CAAC,CAmED"}

package/dist/artifacts/publish/validate/file.d.ts

@@ -0,0 +1,8 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { FileOutline } from "../../outline";
+/** A file artifact is one file of any type, delivered as it is. */
+export declare function validateFileArtifact(files: readonly ArtifactFile[]): {
+    readonly entry: string;
+    readonly outline: FileOutline;
+};
+//# sourceMappingURL=file.d.ts.map

package/dist/artifacts/publish/validate/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAGhD,mEAAmE;AACnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAC9B,CASA"}

package/dist/artifacts/publish/validate/html.d.ts

@@ -0,0 +1,20 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { FoundReference } from "../references";
+/** The file a web artifact, a deck or a page, renders from. */
+export declare const HTML_ENTRY = "index.html";
+/** Where the frame serves the kit and the runtime, beside a web artifact's own files. */
+export declare const FRAME_ASSET_PREFIX = "__sixb/";
+/** Refuses a file under `__sixb/`, where the frame serves its own: it would never be served. */
+export declare function refuseFrameAssetPaths(files: readonly ArtifactFile[], what: string): void;
+/**
+ * Reads the `artifact:` addresses a web artifact's HTML uses, to resolve: links (`<a href>`),
+ * files it shows from other artifacts (`<img src>`), and anything else it shows (`<sixb-embed
+ * src>`), a chart, a range, a section, or a slide, which the app draws over the frame. `at` names
+ * where each sits, such as a deck's slide, and `file` the HTML file it reads. The first thing that
+ * would not render is the refusal.
+ */
+export declare function readHtmlReferences(rewriter: HTMLRewriter, at: () => string, file?: string): {
+    readonly references: FoundReference[];
+    readonly refusal: () => string | undefined;
+};
+//# sourceMappingURL=html.d.ts.map

package/dist/artifacts/publish/validate/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/html.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAIpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,+DAA+D;AAC/D,eAAO,MAAM,UAAU,eAAe,CAAA;AAEtC,yFAAyF;AACzF,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C,gGAAgG;AAChG,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAOxF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,EACtB,EAAE,EAAE,MAAM,MAAM,EAChB,IAAI,GAAE,MAAmB,GACxB;IAAE,QAAQ,CAAC,UAAU,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,GAAG,SAAS,CAAA;CAAE,CA4CvF"}

package/dist/artifacts/publish/validate/page.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { PageOutline } from "../../outline";
+import { type ArtifactBlobStorage } from "../files";
+import type { FoundReference } from "../references";
+/**
+ * Reads a page: `index.html` and the files it loads beside it, its scripts, styles, images, and
+ * data. Its `<title>`, else its first `<h1>`, becomes its title in the outline. The `artifact:`
+ * addresses it uses are returned to resolve, as a deck's are.
+ */
+export declare function validatePage(blobStorage: ArtifactBlobStorage, files: readonly ArtifactFile[]): Promise<{
+    readonly entry: string;
+    readonly outline: PageOutline;
+    readonly references: readonly FoundReference[];
+}>;
+//# sourceMappingURL=page.d.ts.map

package/dist/artifacts/publish/validate/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/page.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAGpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,UAAU,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGnD;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,OAAO,CAAC;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;CAC/C,CAAC,CA4CD"}

package/dist/artifacts/publish/validate/sheet.d.ts

@@ -0,0 +1,23 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { SheetOutline } from "../../outline";
+import { type CheckedArtifactQuery } from "../../queries";
+import type { ArtifactWarning } from "../../warnings";
+import { type ArtifactBlobStorage } from "../files";
+import type { FoundReference } from "../references";
+/**
+ * Reads a sheet: `workbook.json`, then each sheet's CSV against it. Every cell of a typed column
+ * must read as its type, every formula must compute its column, and every chart must name columns
+ * its sheet has, so the grid formats and the charts draw the same wherever the sheet is opened.
+ * Rows a formula computes to an error are warnings: the version publishes, and the grid shows them.
+ *
+ * A live sheet is checked against `queries`, what checking the version's queries as its author
+ * learned: its query returns rows, and its columns show properties those rows hold, so its rules
+ * hold as a CSV sheet's do. Its rows are each reader's, so no cell is checked.
+ */
+export declare function validateSheet(blobStorage: ArtifactBlobStorage, files: readonly ArtifactFile[], queries: ReadonlyMap<string, CheckedArtifactQuery>): Promise<{
+    readonly entry: string;
+    readonly outline: SheetOutline;
+    readonly references: readonly FoundReference[];
+    readonly warnings: readonly ArtifactWarning[];
+}>;
+//# sourceMappingURL=sheet.d.ts.map

package/dist/artifacts/publish/validate/sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/sheet.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAMpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAqB,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAWrD,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,UAAU,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,GACjD,OAAO,CAAC;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;CAC9C,CAAC,CA+DD"}

package/dist/artifacts/publish/validate/slides.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types";
+import type { SlidesOutline } from "../../outline";
+import { type ArtifactBlobStorage } from "../files";
+import type { FoundReference } from "../references";
+/**
+ * Reads a deck: `index.html` with one `<section class="slide">` per 1280×720 slide, and the files
+ * it loads beside it. Each slide's first heading becomes its title in the outline. The `artifact:`
+ * addresses it uses are returned with the slide each is on, to resolve.
+ */
+export declare function validateSlides(blobStorage: ArtifactBlobStorage, files: readonly ArtifactFile[]): Promise<{
+    readonly entry: string;
+    readonly outline: SlidesOutline;
+    readonly references: readonly FoundReference[];
+}>;
+//# sourceMappingURL=slides.d.ts.map

package/dist/artifacts/publish/validate/slides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slides.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/publish/validate/slides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAGpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,KAAK,mBAAmB,EAAqC,MAAM,UAAU,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGnD;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,OAAO,CAAC;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;CAC/C,CAAC,CA6DD"}

package/dist/artifacts/queries.d.ts

@@ -0,0 +1,95 @@
+import type { ObjectQuery } from "../objects/query/ir";
+import type { PrimitiveSchema } from "../ontology/types";
+import type { ObjectFacetRequest, ObjectFacetResult, ObjectRow } from "../storage/objects/types";
+import type { ArtifactKind } from "./kinds";
+/**
+ * A version's queries: one `queries/<name>.json` file each, holding what `sixb objects query
+ * --file` runs or `sixb objects facets --file` sends. Each reader runs them with their own rights,
+ * so what an artifact shows is never a copy of what its author could read.
+ */
+export declare const ARTIFACT_QUERIES_DIRECTORY = "queries/";
+/** The kinds that show live data. A document shows a live sheet instead, and a file is as it is. */
+export declare const ARTIFACT_QUERY_KINDS: readonly ArtifactKind[];
+/** A query read from its file: rows, or the facets of the rows. */
+export type ArtifactQuery = {
+    readonly kind: "objects";
+    readonly query: ObjectQuery;
+} | {
+    readonly kind: "facets";
+    readonly query: ObjectQuery;
+    readonly facets: readonly ObjectFacetRequest[];
+};
+/** What a query read for its reader: the rows they may see, or the facets of those rows. */
+export type ArtifactQueryResult = ArtifactObjectsQueryResult | ArtifactFacetsQueryResult;
+/** What a query returns and reads, as whoever runs it may see it. */
+export interface ArtifactQueryShape {
+    /** The object types the query returns. */
+    readonly resultObjectTypeIds: readonly string[];
+    /** Every object type the query reads: where it starts, and each type it traverses or expands. */
+    readonly readObjectTypeIds: readonly string[];
+    /** What each value of a row holds, from the ontology as whoever runs the query may view it. */
+    readonly schema: ArtifactQuerySchema;
+}
+/**
+ * The properties a query's rows hold, and those of the objects it expands on them: what a live
+ * view types its columns by. A property the reader's view of the ontology leaves out is absent.
+ */
+export interface ArtifactQuerySchema {
+    /** By property id, over the types the query returns; the first type's when two disagree. */
+    readonly properties: Readonly<Record<string, ArtifactQueryProperty>>;
+    /** By link id, for each link the query expands on its rows: the properties of what it reaches. */
+    readonly links: Readonly<Record<string, {
+        readonly properties: Readonly<Record<string, ArtifactQueryProperty>>;
+    }>>;
+}
+/** A property's type, with a value type resolved to the schema it names. */
+export interface ArtifactQueryProperty {
+    readonly type: ArtifactQueryPropertyType;
+    /** What an enum's values are. */
+    readonly valueType?: "string" | "integer";
+}
+export type ArtifactQueryPropertyType = PrimitiveSchema | "enum" | "array" | "object" | "map";
+/** What checking a query as its author learned: what it returns, reads, and holds. */
+export interface CheckedArtifactQuery extends ArtifactQueryShape {
+    readonly kind: ArtifactQuery["kind"];
+}
+export interface ArtifactObjectsQueryResult extends ArtifactQueryShape {
+    readonly kind: "objects";
+    /**
+     * At most `ARTIFACT_LIMITS.maxQueryRows`, as the reader reads them: a marked property they are
+     * not cleared for is left out and listed in the row's `redactions`.
+     */
+    readonly objects: readonly ObjectRow[];
+    /** Every row the query matches for the reader, those past the cap included. */
+    readonly total: number;
+    /** Whether rows are left out because of the cap. A query's own `limit` leaves none out. */
+    readonly truncated: boolean;
+}
+export interface ArtifactFacetsQueryResult extends ArtifactQueryShape {
+    readonly kind: "facets";
+    /** Every row the query matches for the reader. */
+    readonly total: number;
+    readonly facets: readonly ObjectFacetResult[];
+}
+export declare function isArtifactQueryName(name: string): boolean;
+export declare function artifactQueryPath(name: string): string;
+/** The query a path names, or `undefined` when it is not one `queries/<name>.json` file. */
+export declare function artifactQueryName(path: string): string | undefined;
+/**
+ * Reads a query file into its query, and where the query sits in the file (`$`, or `$.query` in
+ * a request) so a problem found later names its place in the file. A file is one of:
+ *
+ * - a query node, `{ "kind": "start", ... }`, for rows;
+ * - `{ "query": <node> }`, for rows;
+ * - `{ "query": <node>, "facets": [{ "propertyId": "status", "limit": 10 }] }`, for facets.
+ *
+ * Only what an author writes is read: the fields core resolves itself are refused, as the API
+ * refuses them. `page`, `vector` and `rerank` are refused too, saying why.
+ */
+export declare function parseArtifactQuery(path: string, text: string): {
+    readonly query: ArtifactQuery;
+    readonly at: "$" | "$.query";
+} | {
+    readonly error: string;
+};
+//# sourceMappingURL=queries.d.ts.map

package/dist/artifacts/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/artifacts/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EAGZ,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,aAAa,CAAA;AAEpD,oGAAoG;AACpG,eAAO,MAAM,oBAAoB,EAAE,SAAS,YAAY,EAA0C,CAAA;AAElG,mEAAmE;AACnE,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GACzD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAC/C,CAAA;AAEL,4FAA4F;AAC5F,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,GAAG,yBAAyB,CAAA;AAExF,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/C,iGAAiG;IACjG,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7C,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;IACpE,kGAAkG;IAClG,QAAQ,CAAC,KAAK,EAAE,QAAQ,CACtB,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;KAAE,CAAC,CACzF,CAAA;CACF;AAED,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAA;IACxC,iCAAiC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAC1C;AAED,MAAM,MAAM,yBAAyB,GAAG,eAAe,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAA;AAE7F,sFAAsF;AACtF,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACpE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAA;IACtC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,2FAA2F;IAC3F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,MAAM,WAAW,yBAA0B,SAAQ,kBAAkB;IACnE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAC9C;AAKD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKlE;AAWD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,GAAG,SAAS,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAe9F"}

package/dist/artifacts/references.d.ts

@@ -0,0 +1,12 @@
+/** An `artifact:` address a version uses, recorded when the version is published. */
+export interface ArtifactReference {
+    /** The address as written, such as `artifact:art_k3m9q2x7tp#chart=revenue`. */
+    readonly address: string;
+    /** An embed shows the target in place; a link opens it. */
+    readonly as: "embed" | "link";
+    /** Where the address sits in its host: a heading slug, a slide number, or a sheet cell. */
+    readonly at: string;
+    /** The target's version when this version was published, so later changes can be told apart. */
+    readonly resolvedVersion: number;
+}
+//# sourceMappingURL=references.d.ts.map

package/dist/artifacts/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../src/artifacts/references.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAAA;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,gGAAgG;IAChG,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACjC"}

package/dist/artifacts/resolve.d.ts

@@ -0,0 +1,47 @@
+import { type ArtifactAddress, type CellRange } from "./address";
+import type { ArtifactKind } from "./kinds";
+import type { ArtifactOutline } from "./outline";
+/** The version an address points into: its kind, its outline, and its file list. */
+export interface ArtifactAddressTarget {
+    readonly kind: ArtifactKind;
+    readonly outline: ArtifactOutline;
+    readonly files: readonly {
+        readonly path: string;
+    }[];
+}
+/** What an address names inside its target. */
+export type ResolvedArtifactPart = {
+    readonly type: "artifact";
+} | {
+    readonly type: "file";
+    readonly path: string;
+} | {
+    readonly type: "sheet";
+    readonly sheet: string;
+    readonly range?: CellRange;
+} | {
+    readonly type: "chart";
+    readonly chart: string;
+} | {
+    readonly type: "section";
+    readonly slug: string;
+} | {
+    readonly type: "slide";
+    readonly slide: number;
+} | {
+    readonly type: "board";
+    readonly id: string;
+} | {
+    readonly type: "region";
+    readonly id: string;
+};
+/**
+ * Finds what an address names in a version, against its outline and files. A problem says what is
+ * missing and what the version has instead, so whoever wrote the address can fix it.
+ */
+export declare function resolveArtifactAddress(address: ArtifactAddress, target: ArtifactAddressTarget): {
+    readonly part: ResolvedArtifactPart;
+} | {
+    readonly problem: string;
+};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/artifacts/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/artifacts/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAkB,MAAM,WAAW,CAAA;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAEhD,oFAAoF;AACpF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CACrD;AAED,+CAA+C;AAC/C,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GAC9E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,qBAAqB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA4ExE"}

package/dist/artifacts/run-query.d.ts

@@ -0,0 +1,26 @@
+import type { AuthorizedOntologyView } from "../objects/authorized-ontology-view";
+import { type ValidatedObjectQuery } from "../objects/query/validate";
+import type { SixbRuntimeContext } from "../runtime/types";
+import type { ArtifactQuery, ArtifactQueryResult, ArtifactQuerySchema, ArtifactQueryShape } from "./queries";
+/**
+ * Runs one of a version's queries as the runtime's caller, through their object reader: what they
+ * cannot view refuses the query, and what they are not cleared for is left out of each row.
+ *
+ * The query was valid when it was published, but the ontology may have changed since: a query
+ * that no longer validates, or no longer plans, is `query_invalid`. Rows are read a page at a
+ * time, up to `ARTIFACT_LIMITS.maxQueryRows`, within any `limit` the query declares.
+ */
+export declare function runArtifactQuery(runtime: Pick<SixbRuntimeContext, "ontology" | "objectReader">, name: string, query: ArtifactQuery): Promise<ArtifactQueryResult>;
+/**
+ * What a query returns and reads, and what its rows hold as the runtime's caller may view them. It
+ * throws what validating the query throws.
+ */
+export declare function describeArtifactQuery(runtime: Pick<SixbRuntimeContext, "ontology" | "objectReader">, query: ArtifactQuery): ArtifactQueryShape;
+/**
+ * The properties of the types a validated query returns, and of those each link it expands on its
+ * rows reaches, read from `view`: a reader is never told of a property their view leaves out. A
+ * type the view leaves out adds none. Only the outermost expansions are read, where normalization
+ * puts every expansion of the rows; one nested in another is not.
+ */
+export declare function artifactQuerySchema(view: AuthorizedOntologyView, validated: ValidatedObjectQuery): ArtifactQuerySchema;
+//# sourceMappingURL=run-query.d.ts.map

package/dist/artifacts/run-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-query.d.ts","sourceRoot":"","sources":["../../src/artifacts/run-query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AAGjF,OAAO,EAAE,KAAK,oBAAoB,EAAuB,MAAM,2BAA2B,CAAA;AAE1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAI1D,OAAO,KAAK,EACV,aAAa,EAEb,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,WAAW,CAAA;AAKlB;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,cAAc,CAAC,EAC9D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,mBAAmB,CAAC,CAgB9B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,cAAc,CAAC,EAC9D,KAAK,EAAE,aAAa,GACnB,kBAAkB,CAQpB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,sBAAsB,EAC5B,SAAS,EAAE,oBAAoB,GAC9B,mBAAmB,CAarB"}