@manta-eu/client 0.1.0

package/dist/shared/datastore-path.d.ts

@@ -0,0 +1,19 @@
+export declare const datastoreRoutePrefix = "/d";
+export declare const datastoreHeaderName = "x-manta-datastore";
+export declare const datastoreQueryParam = "datastore";
+export declare const redirectRoutePath = "/redirect";
+export type DatastoreLocation = {
+    datastoreId: string | undefined;
+    path: string;
+};
+export declare function isRootRelativePath(url: string): boolean;
+export declare function datastoreBasename(datastoreId: string): string;
+export declare function parseDatastorePath(pathname: string): DatastoreLocation;
+export declare function datastoreRelativePath(pathname: string): string;
+export declare function datastoreHeader(datastoreId: string | undefined): Record<string, string>;
+export declare function datastoreSocketQuery(datastoreId: string | undefined): Record<string, string>;
+export declare function withDatastoreQueryParam(href: string, datastoreId: string | undefined): string;
+export declare function withDatastorePrefix(datastoreId: string, path: string): string;
+export declare function datastoreScopedRoutePattern(path: string): string;
+export declare function datastoreScopedDenylist(pathWithoutSlash: string): RegExp;
+//# sourceMappingURL=datastore-path.d.ts.map

package/dist/shared/datastore-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore-path.d.ts","sourceRoot":"","sources":["../../src/shared/datastore-path.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAE/C,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAE7C,MAAM,MAAM,iBAAiB,GAAG;IAAE,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAKlF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAQtE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE5F;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM7F;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhE;AAGD,wBAAgB,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAExE"}

package/dist/shared/datastore-path.js

@@ -0,0 +1,62 @@
+import { isValidDatastoreId } from "./datastore-id.js";
+export const datastoreRoutePrefix = "/d";
+export const datastoreHeaderName = "x-manta-datastore";
+export const datastoreQueryParam = "datastore";
+export const redirectRoutePath = "/redirect";
+const datastorePathPattern = new RegExp(`^${datastoreRoutePrefix}/([^/]+)(/.*)?$`);
+// "//evil.com" and "/\evil.com" both resolve off-origin - browsers treat "\" as "/" for special schemes.
+export function isRootRelativePath(url) {
+    return url.startsWith("/") && !url.startsWith("//") && !url.startsWith("/\\");
+}
+export function datastoreBasename(datastoreId) {
+    return `${datastoreRoutePrefix}/${encodeURIComponent(datastoreId)}`;
+}
+export function parseDatastorePath(pathname) {
+    const split = splitDatastorePath(pathname);
+    if (!split)
+        return { datastoreId: undefined, path: pathname };
+    const datastoreId = safeDecode(split.segment);
+    if (!datastoreId || !isValidDatastoreId(datastoreId))
+        return { datastoreId: undefined, path: pathname };
+    return { datastoreId, path: split.rest };
+}
+export function datastoreRelativePath(pathname) {
+    return splitDatastorePath(pathname)?.rest ?? pathname;
+}
+export function datastoreHeader(datastoreId) {
+    return datastoreId ? { [datastoreHeaderName]: datastoreId } : {};
+}
+export function datastoreSocketQuery(datastoreId) {
+    return datastoreId ? { [datastoreQueryParam]: datastoreId } : {};
+}
+export function withDatastoreQueryParam(href, datastoreId) {
+    if (!datastoreId)
+        return href;
+    const url = new URL(href, "http://placeholder");
+    url.searchParams.set(datastoreQueryParam, datastoreId);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+export function withDatastorePrefix(datastoreId, path) {
+    return `${datastoreBasename(datastoreId)}${path}`;
+}
+export function datastoreScopedRoutePattern(path) {
+    return `${datastoreRoutePrefix}/:datastoreId${path}`;
+}
+// Matches a path with or without its "/d/<id>/" prefix, for a Workbox denylist entry.
+export function datastoreScopedDenylist(pathWithoutSlash) {
+    return new RegExp(`^/(${datastoreRoutePrefix.slice(1)}/[^/]+/)?${pathWithoutSlash}\\b`);
+}
+function splitDatastorePath(pathname) {
+    const match = datastorePathPattern.exec(pathname);
+    if (!match?.[1])
+        return undefined;
+    return { segment: match[1], rest: match[2] || "/" };
+}
+function safeDecode(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/shared/datastore-route-table.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from "react";
+export type RouteElements = {
+    Chat: ReactNode;
+    EnterDatastore?: ReactNode;
+    Plans?: ReactNode;
+    Rules?: ReactNode;
+    Explain?: ReactNode;
+    Streams?: ReactNode;
+    Datastores?: ReactNode;
+    Memories?: ReactNode;
+    Activity?: ReactNode;
+    ActivityDetail?: ReactNode;
+    Integrations?: ReactNode;
+    Team?: ReactNode;
+    DataExplorerLayout?: ReactNode;
+    DataExplorerIndex?: ReactNode;
+    DataExplorerRecent?: ReactNode;
+    DataExplorerCoverage?: ReactNode;
+    DataExplorerPrefix?: ReactNode;
+    DataExplorerType?: ReactNode;
+    DataEntity?: ReactNode;
+    DataDetail?: ReactNode;
+    NotFound?: ReactNode;
+};
+export declare function notFoundElement(elements: RouteElements): ReactNode;
+export type RouteDefinition = {
+    path: string;
+    render: (elements: RouteElements) => ReactNode;
+    children?: RouteDefinition[];
+};
+export declare const notFoundRoutePath = "*";
+export declare const globalRoutes: RouteDefinition[];
+export declare const datastoreRoutes: RouteDefinition[];
+export declare const datastoreRoutePaths: string[];
+export declare const globalRoutePaths: string[];
+//# sourceMappingURL=datastore-route-table.d.ts.map

package/dist/shared/datastore-route-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore-route-table.d.ts","sourceRoot":"","sources":["../../src/shared/datastore-route-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,oBAAoB,CAAC,EAAE,SAAS,CAAC;IACjC,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,gBAAgB,CAAC,EAAE,SAAS,CAAC;IAC7B,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,aAAa,aAEtD;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,SAAS,CAAC;IAC/C,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,eAAO,MAAM,YAAY,EAAE,eAAe,EAEzC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAAe,EA4B5C,CAAC;AAMF,eAAO,MAAM,mBAAmB,EAAE,MAAM,EAEvC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,MAAM,EAA+B,CAAC"}

package/dist/shared/datastore-route-table.js

@@ -0,0 +1,43 @@
+export function notFoundElement(elements) {
+    return elements.NotFound || elements.Chat;
+}
+export const notFoundRoutePath = "*";
+export const globalRoutes = [
+    { path: "/datastores", render: (e) => e.Datastores || notFoundElement(e) },
+];
+export const datastoreRoutes = [
+    { path: "/", render: (e) => e.Chat },
+    { path: "/plans", render: (e) => e.Plans || e.Chat },
+    { path: "/plans/:planName", render: (e) => e.Plans || e.Chat },
+    { path: "/rules", render: (e) => e.Rules || e.Chat },
+    { path: "/rules/:ruleName", render: (e) => e.Rules || e.Chat },
+    { path: "/explain", render: (e) => e.Explain || e.Chat },
+    { path: "/streams", render: (e) => e.Streams || notFoundElement(e) },
+    { path: "/memories", render: (e) => e.Memories || e.Chat },
+    { path: "/activity", render: (e) => e.Activity || notFoundElement(e) },
+    { path: "/activity/:id", render: (e) => e.ActivityDetail || notFoundElement(e) },
+    { path: "/integrations", render: (e) => e.Integrations || e.Chat },
+    { path: "/team", render: (e) => e.Team || notFoundElement(e) },
+    {
+        path: "/data",
+        render: (e) => e.DataExplorerLayout || e.Chat,
+        children: [
+            { path: "/data", render: (e) => e.DataExplorerIndex || notFoundElement(e) },
+            { path: "/data/recent", render: (e) => e.DataExplorerRecent || notFoundElement(e) },
+            { path: "/data/coverage", render: (e) => e.DataExplorerCoverage || notFoundElement(e) },
+            { path: "/data/entity/:iri", render: (e) => e.DataEntity || notFoundElement(e) },
+            { path: "/data/:prefix", render: (e) => e.DataExplorerPrefix || notFoundElement(e) },
+            { path: "/data/:prefix/:type", render: (e) => e.DataExplorerType || notFoundElement(e) },
+            { path: "/data/:prefix/:type/:id", render: (e) => e.DataDetail || notFoundElement(e) },
+        ],
+    },
+    { path: "/chat/:chatId", render: (e) => e.Chat },
+    { path: notFoundRoutePath, render: notFoundElement },
+];
+function flattenPaths(routes) {
+    return routes.flatMap((route) => [route.path, ...(route.children ? flattenPaths(route.children) : [])]);
+}
+export const datastoreRoutePaths = [
+    ...new Set(flattenPaths(datastoreRoutes).filter((path) => path !== "/" && path !== notFoundRoutePath)),
+];
+export const globalRoutePaths = flattenPaths(globalRoutes);

package/dist/shared/duration.d.ts

@@ -0,0 +1,6 @@
+import type { Duration } from "iso8601-duration";
+export declare function parseDuration(isoDuration: string): Duration | null;
+export declare function formatDuration(isoDuration: string): string;
+export declare function durationToSeconds(isoDuration: string): number | null;
+export declare function formatDurationSmart(isoDuration: string): string;
+//# sourceMappingURL=duration.d.ts.map

package/dist/shared/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/shared/duration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAMlE;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAY1D;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKpE;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CA2B/D"}

package/dist/shared/duration.js

@@ -0,0 +1,55 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { parse, toSeconds } from "iso8601-duration";
+export function parseDuration(isoDuration) {
+    try {
+        return parse(isoDuration);
+    }
+    catch {
+        return null;
+    }
+}
+export function formatDuration(isoDuration) {
+    const duration = parseDuration(isoDuration);
+    if (!duration)
+        return isoDuration;
+    const parts = [];
+    if (duration.days)
+        parts.push(`${duration.days}d`);
+    if (duration.hours)
+        parts.push(`${duration.hours}h`);
+    if (duration.minutes)
+        parts.push(`${duration.minutes}m`);
+    if (duration.seconds)
+        parts.push(`${duration.seconds}s`);
+    return isPresent(parts) ? parts.join(" ") : "0m";
+}
+export function durationToSeconds(isoDuration) {
+    const duration = parseDuration(isoDuration);
+    if (!duration)
+        return null;
+    return toSeconds(duration);
+}
+export function formatDurationSmart(isoDuration) {
+    const duration = parseDuration(isoDuration);
+    if (!duration)
+        return isoDuration;
+    const totalSeconds = toSeconds(duration);
+    if (totalSeconds < 60) {
+        return `${Math.round(totalSeconds)}s`;
+    }
+    if (totalSeconds < 3600) {
+        const minutes = Math.round(totalSeconds / 60);
+        return `${minutes}m`;
+    }
+    if (totalSeconds < 86400) {
+        const hours = Math.floor(totalSeconds / 3600);
+        const remainingMinutes = Math.round((totalSeconds % 3600) / 60);
+        return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+    }
+    const days = Math.floor(totalSeconds / 86400);
+    const remainingHours = Math.floor((totalSeconds % 86400) / 3600);
+    if (remainingHours > 0) {
+        return `${days}d ${remainingHours}h`;
+    }
+    return `${days}d`;
+}

package/dist/shared/entity-set.d.ts

@@ -0,0 +1,14 @@
+import { type JsonLdGraphDocument } from "../types/jsonld.js";
+export declare const selfFetchingTypes: string[];
+export declare const displayFactTypes: string[];
+export declare function entityTypesByIri(graph: JsonLdGraphDocument): Map<string, string[]>;
+export type EntityTypeGroup = {
+    typeIris: string[];
+    iris: string[];
+};
+export declare function groupEntitiesByType(entityIris: readonly string[], typesByIri: Map<string, string[]>): {
+    key: string;
+    typeIris: string[];
+    iris: string[];
+}[];
+//# sourceMappingURL=entity-set.d.ts.map

package/dist/shared/entity-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-set.d.ts","sourceRoot":"","sources":["../../src/shared/entity-set.ts"],"names":[],"mappings":"AACA,OAAO,EAA2C,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAKpG,eAAO,MAAM,iBAAiB,UAAoC,CAAC;AAEnE,eAAO,MAAM,gBAAgB,UAAkC,CAAC;AAEhE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,yBAU1D;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAErE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;;;;IAQnG"}

package/dist/shared/entity-set.js

@@ -0,0 +1,25 @@
+import { expandPrefix } from "./rdf-namespaces.js";
+import { getJsonLdGraph, getNodeId, getNodeTypes } from "../types/jsonld.js";
+import { isPresent } from "@manta-eu/lib/present";
+import { detailViewTypes, lensViewTypes } from "@manta-eu/rdf-lib/detail-view-types";
+import { groupBy, toPairs } from "ramda";
+export const selfFetchingTypes = detailViewTypes.map(expandPrefix);
+export const displayFactTypes = lensViewTypes.map(expandPrefix);
+export function entityTypesByIri(graph) {
+    const typesByIri = new Map();
+    for (const node of getJsonLdGraph(graph)) {
+        const id = getNodeId(node);
+        if (id === undefined)
+            continue;
+        typesByIri.set(expandPrefix(id), getNodeTypes(node).map(expandPrefix));
+    }
+    return typesByIri;
+}
+export function groupEntitiesByType(entityIris, typesByIri) {
+    const typeKey = (iri) => [...(typesByIri.get(expandPrefix(iri)) ?? [])].sort().join("|");
+    return toPairs(groupBy(typeKey, entityIris)).map(([key, iris = []]) => ({
+        key,
+        typeIris: isPresent(key) ? key.split("|") : [],
+        iris,
+    }));
+}

package/dist/shared/error-utils.d.ts

@@ -0,0 +1,23 @@
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+export type ErrorInfo = {
+    message: string;
+    description?: string;
+};
+export type HttpError = Error & {
+    status: ContentfulStatusCode;
+};
+export declare function createHttpError(message: string, status: ContentfulStatusCode): HttpError;
+export declare function isHttpError(e: unknown): e is HttpError;
+export declare function serializeError(error: unknown): {
+    name: string;
+    message: string;
+    stack: string | undefined;
+    value?: undefined;
+} | {
+    value: string;
+    name?: undefined;
+    message?: undefined;
+    stack?: undefined;
+};
+export declare function parseError(error: unknown, defaultMessage: string): ErrorInfo;
+//# sourceMappingURL=error-utils.d.ts.map

package/dist/shared/error-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-utils.d.ts","sourceRoot":"","sources":["../../src/shared/error-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG;IAAE,MAAM,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAEjE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAIxF;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD;AAkBD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO;;;;;;;;;;EAI5C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,SAAS,CAoC5E"}

package/dist/shared/error-utils.js

@@ -0,0 +1,56 @@
+export function createHttpError(message, status) {
+    const err = new Error(message);
+    err.status = status;
+    return err;
+}
+export function isHttpError(e) {
+    return e instanceof Error && typeof e.status === "number";
+}
+function isNetworkError(error) {
+    return (error instanceof TypeError &&
+        (error.message.includes("fetch") || error.message.includes("network") || error.message.includes("Failed to fetch")));
+}
+function isGraphQLError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "message" in error &&
+        (("graphQLErrors" in error && Array.isArray(error.graphQLErrors)) || "networkError" in error));
+}
+export function serializeError(error) {
+    if (error instanceof Error)
+        return { name: error.name, message: error.message, stack: error.stack };
+    return { value: String(error) };
+}
+export function parseError(error, defaultMessage) {
+    if (error instanceof Error) {
+        if (isNetworkError(error)) {
+            return {
+                message: defaultMessage,
+                description: "Network error. Please check your connection and try again.",
+            };
+        }
+        return {
+            message: defaultMessage,
+            description: error.message,
+        };
+    }
+    if (isGraphQLError(error) && error.graphQLErrors && Array.isArray(error.graphQLErrors)) {
+        const firstError = error.graphQLErrors[0];
+        if (typeof firstError === "object" && firstError && "message" in firstError) {
+            return {
+                message: defaultMessage,
+                description: String(firstError.message),
+            };
+        }
+    }
+    if (typeof error === "string") {
+        return {
+            message: defaultMessage,
+            description: error,
+        };
+    }
+    return {
+        message: defaultMessage,
+        description: "An unexpected error occurred",
+    };
+}

package/dist/shared/explorer-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const explorerPath = "/data";
+export declare const entitySegment = "entity";
+export declare function entityPath(iri: string): string;
+//# sourceMappingURL=explorer-paths.d.ts.map

package/dist/shared/explorer-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer-paths.d.ts","sourceRoot":"","sources":["../../src/shared/explorer-paths.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,UAAU,CAAC;AAEpC,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C"}

package/dist/shared/explorer-paths.js

@@ -0,0 +1,7 @@
+// The URL shape of the data explorer. The server redirects into these paths and the app routes
+// them, so both sides must read one definition.
+export const explorerPath = "/data";
+export const entitySegment = "entity";
+export function entityPath(iri) {
+    return `${explorerPath}/${entitySegment}/${encodeURIComponent(iri)}`;
+}

package/dist/shared/fileIri.d.ts

@@ -0,0 +1,12 @@
+export declare const fileIriScheme = "s3";
+export declare function buildFileIri(input: {
+    bucket: string;
+    key: string;
+}): string;
+export declare function isFileIri(iri: string): boolean;
+export declare function validateFileIri(iri: string): void;
+export declare function parseFileIri(iri: string): {
+    bucket: string;
+    storageKey: string;
+};
+//# sourceMappingURL=fileIri.d.ts.map

package/dist/shared/fileIri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileIri.d.ts","sourceRoot":"","sources":["../../src/shared/fileIri.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,OAAO,CAAC;AAIlC,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,UAElE;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,WAEpC;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,QAI1C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM;;;EAMvC"}

package/dist/shared/fileIri.js

@@ -0,0 +1,18 @@
+export const fileIriScheme = "s3";
+const fileIriPattern = /^s3:\/\/([^/]+)\/(.+)$/;
+export function buildFileIri(input) {
+    return `${fileIriScheme}://${input.bucket}/${input.key}`;
+}
+export function isFileIri(iri) {
+    return fileIriPattern.test(iri);
+}
+export function validateFileIri(iri) {
+    if (!isFileIri(iri)) {
+        throw new Error(`Invalid file IRI: expected ${fileIriScheme}://<bucket>/<key> - got "${iri}"`);
+    }
+}
+export function parseFileIri(iri) {
+    validateFileIri(iri);
+    const [, bucket = "", storageKey = ""] = fileIriPattern.exec(iri) ?? [];
+    return { bucket, storageKey };
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,22 @@
+import type { PageContext } from "./page-context.js";
+import type { UIMessage } from "ai";
+import type { OperatorAllowedModel } from "./model.js";
+export declare const APPROVAL: {
+    readonly YES: "Yes, confirmed.";
+    readonly NO: "No, denied.";
+};
+export type AssistantResponseState = "in-progress" | "finished" | "failed" | "aborted";
+export type ChatUIMessage = UIMessage<{
+    createdAt: string;
+    userId?: string;
+    datastoreId?: string;
+    totalTokens?: number;
+    finishReason?: string;
+    responseState?: AssistantResponseState;
+    isTask?: boolean;
+    traceId?: string;
+    pageContext?: PageContext;
+    model?: OperatorAllowedModel;
+}>;
+export declare function chatIdToPath(id: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGpD,eAAO,MAAM,QAAQ;;;CAGX,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAAG,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEvF,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B,CAAC,CAAC;AAEH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,UAEtC"}

package/dist/shared/index.js

@@ -0,0 +1,8 @@
+// Approval string to be shared across frontend and backend
+export const APPROVAL = {
+    YES: "Yes, confirmed.",
+    NO: "No, denied.",
+};
+export function chatIdToPath(id) {
+    return `/chat/${encodeURIComponent(id)}`;
+}

package/dist/shared/live-context.d.ts

@@ -0,0 +1,2 @@
+export declare const liveContextMemoryDateFilter = "FILTER NOT EXISTS {\n        ?entity a :Memory .\n        {\n          ?entity :memoryTrustedUntil ?horizon .\n          FILTER(?horizon <= NOW())\n        } UNION {\n          ?entity :memoryValidUntil ?expiry .\n          FILTER(?expiry <= NOW())\n        } UNION {\n          ?entity :memoryValidFrom ?validFrom .\n          FILTER(?validFrom > NOW())\n        }\n      }";
+//# sourceMappingURL=live-context.d.ts.map

package/dist/shared/live-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-context.d.ts","sourceRoot":"","sources":["../../src/shared/live-context.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,2XAYhC,CAAC"}

package/dist/shared/live-context.js

@@ -0,0 +1,15 @@
+// :now[:Clock] is MAX(schema:dateModified) over ingested platform data, not real time, and is unbound on an
+// empty datastore - every reader of :LiveContext_Chat has to apply memory dates itself, against NOW().
+export const liveContextMemoryDateFilter = `FILTER NOT EXISTS {
+        ?entity a :Memory .
+        {
+          ?entity :memoryTrustedUntil ?horizon .
+          FILTER(?horizon <= NOW())
+        } UNION {
+          ?entity :memoryValidUntil ?expiry .
+          FILTER(?expiry <= NOW())
+        } UNION {
+          ?entity :memoryValidFrom ?validFrom .
+          FILTER(?validFrom > NOW())
+        }
+      }`;

package/dist/shared/maintenance-schedule.d.ts

@@ -0,0 +1,11 @@
+export declare const maintenanceTickMinutes = 30;
+export declare const compactionPeriodHours = 24;
+export declare function ticksInPeriod(periodHours: number): number;
+export declare function stableSlot(key: string, slots: number): number;
+export declare function sampledByKey(key: string, rate: number): boolean;
+export declare function currentTick(now: Date, periodHours: number): number;
+export declare function isDueThisTick(key: string, now: Date, periodHours: number): boolean;
+export declare function dueThisTick(keys: readonly string[], now: Date, periodHours: number): string[];
+export declare const redundancySweepDayBuckets = 7;
+export declare function isDueOnDay(key: string, now: Date, buckets?: number): boolean;
+//# sourceMappingURL=maintenance-schedule.d.ts.map

package/dist/shared/maintenance-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance-schedule.d.ts","sourceRoot":"","sources":["../../src/shared/maintenance-schedule.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAGD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAM/D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAGlF;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7F;AAED,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,GAAE,MAAkC,GAAG,OAAO,CAGvG"}

package/dist/shared/maintenance-schedule.js

@@ -0,0 +1,38 @@
+import { msPerDay } from "./memory-dates.js";
+export const maintenanceTickMinutes = 30;
+export const compactionPeriodHours = 24;
+export function ticksInPeriod(periodHours) {
+    return Math.max(1, Math.round((periodHours * 60) / maintenanceTickMinutes));
+}
+// This is FNV-1a, kept synchronous because this file ships to the browser without node:crypto.
+export function stableSlot(key, slots) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < key.length; i++) {
+        hash ^= key.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash % slots;
+}
+export function sampledByKey(key, rate) {
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    // 0x100000000 is 2^32, the hash's full range, so dividing by it maps the hash to a fraction in [0, 1).
+    return stableSlot(key, 0x100000000) / 0x100000000 < rate;
+}
+export function currentTick(now, periodHours) {
+    return Math.floor(now.getTime() / (maintenanceTickMinutes * 60_000)) % ticksInPeriod(periodHours);
+}
+export function isDueThisTick(key, now, periodHours) {
+    const slots = ticksInPeriod(periodHours);
+    return stableSlot(key, slots) === currentTick(now, periodHours);
+}
+export function dueThisTick(keys, now, periodHours) {
+    return keys.filter((key) => isDueThisTick(key, now, periodHours));
+}
+export const redundancySweepDayBuckets = 7;
+export function isDueOnDay(key, now, buckets = redundancySweepDayBuckets) {
+    const day = Math.floor(now.getTime() / msPerDay) % buckets;
+    return stableSlot(key, buckets) === day;
+}

package/dist/shared/memory-citation-sampling.d.ts

@@ -0,0 +1,16 @@
+export declare const memoryCitationSampleRate = 0.1;
+export declare function shouldRequestCitations(seed: string, rate?: number): boolean;
+export type CitationRequestTurn = {
+    hasPersonalPreload: boolean;
+    hasSharedSections: boolean;
+    seed: string;
+};
+export type CitationDecision = {
+    requested: false;
+    reason: "none";
+} | {
+    requested: true;
+    reason: "personal" | "sampled";
+};
+export declare function citationDecisionForTurn(turn: CitationRequestTurn, rate?: number): CitationDecision;
+//# sourceMappingURL=memory-citation-sampling.d.ts.map

package/dist/shared/memory-citation-sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-citation-sampling.d.ts","sourceRoot":"","sources":["../../src/shared/memory-citation-sampling.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAiC,GAAG,OAAO,CAErG;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GACxB;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;CAAE,CAAC;AAExD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAMlG"}

package/dist/shared/memory-citation-sampling.js

@@ -0,0 +1,14 @@
+import { sampledByKey } from "./maintenance-schedule.js";
+// citeMemories under-counts memories that work by suppressing an answer; treat as diagnostic, not a score.
+export const memoryCitationSampleRate = 0.1;
+export function shouldRequestCitations(seed, rate = memoryCitationSampleRate) {
+    return sampledByKey(seed, rate);
+}
+export function citationDecisionForTurn(turn, rate) {
+    if (turn.hasPersonalPreload)
+        return { requested: true, reason: "personal" };
+    if (turn.hasSharedSections && shouldRequestCitations(turn.seed, rate)) {
+        return { requested: true, reason: "sampled" };
+    }
+    return { requested: false, reason: "none" };
+}

package/dist/shared/memory-confidence.d.ts

@@ -0,0 +1,3 @@
+export declare const unreviewedMemoryConfidence = 0.7;
+export declare function normalizeConfidence(value: number): number;
+//# sourceMappingURL=memory-confidence.d.ts.map

package/dist/shared/memory-confidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-confidence.d.ts","sourceRoot":"","sources":["../../src/shared/memory-confidence.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGzD"}

package/dist/shared/memory-confidence.js

@@ -0,0 +1,7 @@
+import { clamp } from "ramda";
+export const unreviewedMemoryConfidence = 0.7;
+export function normalizeConfidence(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.round(clamp(0, 1, value) * 100) / 100;
+}

package/dist/shared/memory-consolidation-limits.d.ts

@@ -0,0 +1,6 @@
+export declare const consolidationChunkSize = 12;
+export declare const consolidationMaxChunks = 12;
+export declare const consolidationCandidateLimit: number;
+export declare const consolidationSeedBatchSize = 8;
+export declare const consolidationJudgeBatchSize = 4;
+//# sourceMappingURL=memory-consolidation-limits.d.ts.map

package/dist/shared/memory-consolidation-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-consolidation-limits.d.ts","sourceRoot":"","sources":["../../src/shared/memory-consolidation-limits.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,2BAA2B,QAAkD,CAAC;AAE3F,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,eAAO,MAAM,2BAA2B,IAAI,CAAC"}

package/dist/shared/memory-consolidation-limits.js

@@ -0,0 +1,5 @@
+export const consolidationChunkSize = 12;
+export const consolidationMaxChunks = 12;
+export const consolidationCandidateLimit = consolidationChunkSize * consolidationMaxChunks;
+export const consolidationSeedBatchSize = 8;
+export const consolidationJudgeBatchSize = 4;

package/dist/shared/memory-dates.d.ts

@@ -0,0 +1,3 @@
+export declare const msPerDay: number;
+export declare function parseMemoryDate(value: Date | string | null | undefined): Date | null;
+//# sourceMappingURL=memory-dates.d.ts.map

package/dist/shared/memory-dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-dates.d.ts","sourceRoot":"","sources":["../../src/shared/memory-dates.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,QAAsB,CAAC;AAE5C,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,CAIpF"}

package/dist/shared/memory-dates.js

@@ -0,0 +1,7 @@
+export const msPerDay = 24 * 60 * 60 * 1000;
+export function parseMemoryDate(value) {
+    if (!value)
+        return null;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}