@segmentstream-cloud/ontology 0.16.0 → 0.18.0

package/README.md

@@ -11,7 +11,7 @@ action and is kept in history.
 TypeScript definitions, handler records and SDK calls use camelCase: `jobTitle`,
 `assignedOwnerId`, `createdAt`, and `changeStatus`. The SDK converts ontology names,
 select identifiers and declared action input fields to snake_case for the generated
-REST API, version 6 manifest and storage. TypeScript helpers and options stay
+REST API, version 7 manifest and storage. TypeScript helpers and options stay
 camelCase. JSON property contents, provider payloads, opaque action results and
 historical change names remain data and are preserved. `formatManifest` serializes
 the canonical wire contract shared by REST, storage and future transports.
@@ -28,9 +28,22 @@ one Effect version.
 `ontology/` is a package of its own. The SDK is an ES module, so `ontology/package.json`
 must set `"type": "module"`.
 
+SDK 0.17.0 writes manifest version 7. It adds `m.avg`, `m.min` and `m.max`; a `where` option on
+every aggregate, so that a measure reads only the rows its conditions accept (`m.sum("amount",
+{ where: [{ property: "status", operator: "equals", value: "won" }], description })`); and
+`balanceOver`, which names the date a measure's rows are snapshots over, so that requests group by
+it or filter it to one day. Aggregate requests
+take the `notEquals`, `notIn`, `gt`, `gte`, `lt`, `lte`, `contains`, `startsWith`, `endsWith` and
+`inPeriod` operators, the `hour`, `quarter` and `year` granularities and a `timezone`. See
+[ontology aggregates](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-aggregates.md).
+
 SDK 0.14.0 lets the app's own agent call the service as a paired member (see
 [Agents](#agents)). Its migration adds the agent's runtime tables.
 
+SDK 0.18.0 lets blob properties store any file. `accept` is optional and can restrict a
+property to exact MIME types or ranges. Existing explicit restrictions keep their meaning.
+See [File storage](#file-storage).
+
 SDK 0.12.0 adds warehouse replication enabled by default for all stored business entities,
 fields and business relationships. Existing history captures immutable snapshots and the
 service wakes the publisher after commits. Upgrade and redeploy to activate it; workspace
@@ -64,6 +77,62 @@ SDK 0.13.0 also serves aggregates. Upgrade notes:
 See [ontology aggregates](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-aggregates.md)
 and [ontology analytics](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-aggregates-spec.md).
 
+## File storage
+
+Use `p.blob({ description: "Original source file." })` to retain a file's original bytes.
+Without `accept`, a blob property accepts every concrete MIME type, including custom formats
+and `application/octet-stream`. `p.blob()` also defaults to all files, though ontology checks
+require a description. The manifest publishes this policy as `accept: ["*/*"]`.
+
+Restrict a property when its business rules require a format:
+
+```ts
+content: p.blob({
+  description: "Original POS report or bank statement.",
+  accept: [
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-excel",
+    "text/csv",
+    "text/tab-separated-values",
+  ],
+  maxBytes: 10 * 1024 * 1024,
+}),
+```
+
+`accept` takes MIME types, not extensions. Matching ignores case; `image/*` accepts image
+types and `*/*` accepts all types. Empty lists, duplicate entries, invalid MIME types and
+parameters such as `; charset=utf-8` are rejected during ontology checks.
+`BLOB_CONTENT_TYPES` lists common types as a convenience; it is not a global allow-list.
+
+| Source format         | MIME type                                                                 |
+| --------------------- | ------------------------------------------------------------------------- |
+| XLSX                  | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`       |
+| XLS                   | `application/vnd.ms-excel`                                                |
+| CSV                   | `text/csv`                                                                |
+| TSV                   | `text/tab-separated-values`                                               |
+| JSON                  | `application/json`                                                        |
+| TXT                   | `text/plain`                                                              |
+| DOCX                  | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` |
+| ZIP                   | `application/zip`                                                         |
+| Unknown binary format | `application/octet-stream`                                                |
+
+Uploads still require a valid concrete MIME type, a nonempty file within the property's
+`maxBytes` and the 25 MiB service limit, available workspace quota and action permissions.
+Completion verifies the stored MIME metadata, exact byte count and upload-session binding.
+PDF, JPEG and PNG retain their prefix-signature checks; plain text retains its UTF-8 prefix
+check. Other formats are stored as opaque bytes, without parsing, conversion, archive
+extraction or malware scanning. A MIME declaration does not prove what a file contains.
+Downloads use attachment disposition; only JPEG and PNG may request inline display.
+Agent attachment promotion honors the same `accept` and `maxBytes` restrictions.
+
+Upgrade the ontology SDK to 0.18.0 or later, update any existing `accept` list that should
+allow more types, then check, migrate and redeploy the ontology. The app SDK storage client
+0.13.1 or later uses `application/octet-stream` when the browser supplies no MIME type.
+REST callers should supply that type themselves for unknown formats.
+
+See [blob storage](https://github.com/segmentstream/segmentstream/blob/main/docs/ontology-blob-storage-implementation.md)
+for upload tickets, transfer grants and retained revisions.
+
 ## Define the ontology
 
 ```ts

package/dist/aggregate-filters.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The filter operators of aggregates and the values each takes, shared by the service's request
+ * schemas and `check`'s measure conditions (docs/ontology-aggregates-release-2-spec.md, "Filters").
+ * The rules and messages are SegmentStream's own (backend-next's `semantics/core/predicates.ts`), so
+ * the SDK, the service and the platform refuse alike.
+ */
+/** A filter value: a literal. */
+export type AggregateValue = string | number | boolean;
+/** The operators of a model-level aggregate's filters. */
+export declare const AGGREGATE_FILTER_OPERATORS: readonly ["equals", "in", "isNull", "isNotNull", "between", "notEquals", "notIn", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "inPeriod"];
+/**
+ * The operators of the per-entity shorthand, which bounds dates with `dateRange` instead of
+ * `between` and `inPeriod`.
+ */
+export declare const ENTITY_AGGREGATE_FILTER_OPERATORS: readonly ["equals", "in", "isNull", "isNotNull", "notEquals", "notIn", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith"];
+/**
+ * The operators of a measure condition: a model-level filter's, except `inPeriod`, whose dates would
+ * move with the day a request runs.
+ */
+export declare const MEASURE_CONDITION_OPERATORS: readonly ["equals", "in", "notEquals", "notIn", "isNull", "isNotNull", "between", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith"];
+export type MeasureConditionOperator = (typeof MEASURE_CONDITION_OPERATORS)[number];
+/** The periods `inPeriod` takes without a count. Weeks start on Monday. */
+export declare const AGGREGATE_PERIODS: readonly ["today", "yesterday", "this week", "this month", "this quarter", "this year", "this week to date", "this month to date", "this quarter to date", "this year to date", "last week", "last month", "last quarter", "last year"];
+/**
+ * The units of `last N <unit>`, N at least 1: `last N days` ends yesterday; the others are the N
+ * whole units before the current one.
+ */
+export declare const AGGREGATE_PERIOD_UNITS: readonly ["days", "weeks", "months", "quarters", "years"];
+/** The most values `in` and `notIn` take. */
+export declare const MAXIMUM_FILTER_VALUES = 100;
+/** An operator and the values given to it, before they are known to suit each other. */
+export interface FilterValues {
+    readonly operator: string;
+    readonly value?: unknown;
+    readonly values?: ReadonlyArray<unknown>;
+}
+/** Why an operator does not take the values given, or `undefined` when it does. */
+export declare function filterValuesIssue(filter: FilterValues): string | undefined;
+/** How SegmentStream compares a dimension's values. */
+export type DimensionType = "string" | "decimal" | "boolean" | "date" | "timestamp";
+/** The dimension type of a property type, or `undefined` for JSON and files, which are none. */
+export declare function dimensionTypeOf(propertyType: string): DimensionType | undefined;
+/**
+ * Why a filter's values do not suit its dimension's type, or `undefined` when they do: the operator
+ * must apply to the type and every value must match it. Their count is {@link filterValuesIssue}'s
+ * to check first. `inPeriod` values are periods, which SegmentStream resolves.
+ */
+export declare function filterTypeIssue(filter: FilterValues, type: DimensionType): string | undefined;

package/dist/aggregate-filters.js

@@ -0,0 +1,252 @@
+/**
+ * The filter operators of aggregates and the values each takes, shared by the service's request
+ * schemas and `check`'s measure conditions (docs/ontology-aggregates-release-2-spec.md, "Filters").
+ * The rules and messages are SegmentStream's own (backend-next's `semantics/core/predicates.ts`), so
+ * the SDK, the service and the platform refuse alike.
+ */
+/** The operators of a model-level aggregate's filters. */
+export const AGGREGATE_FILTER_OPERATORS = [
+    "equals",
+    "in",
+    "isNull",
+    "isNotNull",
+    "between",
+    "notEquals",
+    "notIn",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "inPeriod",
+];
+/**
+ * The operators of the per-entity shorthand, which bounds dates with `dateRange` instead of
+ * `between` and `inPeriod`.
+ */
+export const ENTITY_AGGREGATE_FILTER_OPERATORS = [
+    "equals",
+    "in",
+    "isNull",
+    "isNotNull",
+    "notEquals",
+    "notIn",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+];
+/**
+ * The operators of a measure condition: a model-level filter's, except `inPeriod`, whose dates would
+ * move with the day a request runs.
+ */
+export const MEASURE_CONDITION_OPERATORS = [
+    "equals",
+    "in",
+    "notEquals",
+    "notIn",
+    "isNull",
+    "isNotNull",
+    "between",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "startsWith",
+    "endsWith",
+];
+/** The periods `inPeriod` takes without a count. Weeks start on Monday. */
+export const AGGREGATE_PERIODS = [
+    "today",
+    "yesterday",
+    "this week",
+    "this month",
+    "this quarter",
+    "this year",
+    "this week to date",
+    "this month to date",
+    "this quarter to date",
+    "this year to date",
+    "last week",
+    "last month",
+    "last quarter",
+    "last year",
+];
+/**
+ * The units of `last N <unit>`, N at least 1: `last N days` ends yesterday; the others are the N
+ * whole units before the current one.
+ */
+export const AGGREGATE_PERIOD_UNITS = ["days", "weeks", "months", "quarters", "years"];
+/** The most values `in` and `notIn` take. */
+export const MAXIMUM_FILTER_VALUES = 100;
+const COMPARISONS = new Set(["gt", "gte", "lt", "lte"]);
+const TEXT_OPERATORS = new Set(["contains", "startsWith", "endsWith"]);
+function oneValue({ value, values }) {
+    return value !== undefined && values === undefined;
+}
+function someValues({ value, values }) {
+    return (value === undefined &&
+        values !== undefined &&
+        values.length > 0 &&
+        values.length <= MAXIMUM_FILTER_VALUES);
+}
+/** Why an operator does not take the values given, or `undefined` when it does. */
+export function filterValuesIssue(filter) {
+    const { operator, value, values } = filter;
+    if (COMPARISONS.has(operator)) {
+        return oneValue(filter) ? undefined : "Comparison filters require one value.";
+    }
+    if (TEXT_OPERATORS.has(operator)) {
+        return oneValue(filter) && typeof value === "string" && value !== ""
+            ? undefined
+            : "Text filters require one non-empty string.";
+    }
+    switch (operator) {
+        case "equals":
+        case "notEquals":
+            return oneValue(filter) ? undefined : "Equality filters require one value.";
+        case "in":
+            return someValues(filter)
+                ? undefined
+                : "Membership filters require between 1 and 100 values.";
+        case "notIn":
+            return someValues(filter) ? undefined : "notIn requires between 1 and 100 values.";
+        case "between":
+            return value === undefined && values?.length === 2
+                ? undefined
+                : "between needs two values in order.";
+        case "inPeriod":
+            // Whether the value is a period is SegmentStream's to say: it resolves it.
+            return oneValue(filter) ? undefined : "inPeriod filters require one period.";
+        case "isNull":
+        case "isNotNull":
+            return value === undefined && values === undefined
+                ? undefined
+                : "Null filters do not accept values.";
+        default:
+            return undefined;
+    }
+}
+const DIMENSION_TYPES = {
+    text: "string",
+    email: "string",
+    url: "string",
+    select: "string",
+    integer: "decimal",
+    number: "decimal",
+    boolean: "boolean",
+    date: "date",
+    timestamp: "timestamp",
+};
+/** The dimension type of a property type, or `undefined` for JSON and files, which are none. */
+export function dimensionTypeOf(propertyType) {
+    return Object.hasOwn(DIMENSION_TYPES, propertyType) ? DIMENSION_TYPES[propertyType] : undefined;
+}
+function isDate(value) {
+    return (typeof value === "string" &&
+        /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+        !Number.isNaN(Date.parse(value)) &&
+        new Date(value).toISOString().slice(0, 10) === value);
+}
+/** Whether a value is a literal of the type, as SegmentStream reads filter values. */
+function matches(value, type) {
+    if (type === "boolean") {
+        return typeof value === "boolean";
+    }
+    if (type === "decimal") {
+        return ((typeof value === "number" || typeof value === "string") &&
+            String(value).length <= 100 &&
+            /^[-+]?(?:\d+\.?\d*|\.\d+)$/.test(String(value)) &&
+            Number.isFinite(Number(value)));
+    }
+    if (typeof value !== "string" || value.length > 2048) {
+        return false;
+    }
+    if (type === "timestamp") {
+        return (/^\d{4}-\d{2}-\d{2}T/.test(value) &&
+            /(?:Z|[+-]\d{2}:\d{2})$/.test(value) &&
+            Number.isFinite(Date.parse(value)));
+    }
+    return type !== "date" || isDate(value);
+}
+/** Bounds of a timestamp may be dates, which cover whole days; then they are compared as dates. */
+function boundType(bounds, type) {
+    return type === "timestamp" && bounds.every(isDate) ? "date" : type;
+}
+/** Compares two decimal literals exactly, as their digits say, however many there are. */
+function compareDecimals(left, right) {
+    const parse = (value) => {
+        const negative = value.startsWith("-");
+        const [whole = "", fraction = ""] = value.replace(/^[-+]/, "").split(".");
+        const digits = whole.replace(/^0+/, "");
+        const decimals = fraction.replace(/0+$/, "");
+        const zero = digits === "" && decimals === "";
+        return { negative: negative && !zero, digits, decimals };
+    };
+    const a = parse(left);
+    const b = parse(right);
+    if (a.negative !== b.negative) {
+        return a.negative ? -1 : 1;
+    }
+    const width = Math.max(a.decimals.length, b.decimals.length);
+    const magnitude = (value) => value.digits.padStart(Math.max(a.digits.length, b.digits.length), "0") +
+        value.decimals.padEnd(width, "0");
+    // Equal-length digit strings order as their values do.
+    const [first, second] = [magnitude(a), magnitude(b)];
+    if (first === second) {
+        return 0;
+    }
+    const sign = first < second ? -1 : 1;
+    return a.negative ? -sign : sign;
+}
+function inOrder(from, to, type) {
+    if (type === "decimal") {
+        return compareDecimals(String(from), String(to)) <= 0;
+    }
+    if (type === "timestamp") {
+        return Date.parse(String(from)) <= Date.parse(String(to));
+    }
+    return String(from) <= String(to);
+}
+const MISMATCH = "Filter value does not match its dimension type.";
+const ORDERED_TYPES = new Set(["date", "timestamp", "decimal"]);
+/**
+ * Why a filter's values do not suit its dimension's type, or `undefined` when they do: the operator
+ * must apply to the type and every value must match it. Their count is {@link filterValuesIssue}'s
+ * to check first. `inPeriod` values are periods, which SegmentStream resolves.
+ */
+export function filterTypeIssue(filter, type) {
+    const { operator, value, values = [] } = filter;
+    const given = value === undefined ? values : [value];
+    if (operator === "between") {
+        const [from, to] = given;
+        const bounds = boundType([from, to], type);
+        if (!ORDERED_TYPES.has(type)) {
+            return "between filters date, timestamp and number dimensions.";
+        }
+        if (!matches(from, bounds) || !matches(to, bounds)) {
+            return MISMATCH;
+        }
+        return inOrder(from, to, bounds) ? undefined : "between needs two values in order.";
+    }
+    if (operator === "inPeriod") {
+        return type === "date" || type === "timestamp"
+            ? undefined
+            : "inPeriod filters date and timestamp dimensions.";
+    }
+    if (COMPARISONS.has(operator) && !ORDERED_TYPES.has(type)) {
+        return `${operator} filters date, timestamp and number dimensions.`;
+    }
+    if (TEXT_OPERATORS.has(operator) && type !== "string") {
+        return `${operator} filters text dimensions.`;
+    }
+    // A comparison bounds a timestamp by a date or by an exact instant, as `between` does.
+    const valueType = COMPARISONS.has(operator) ? boundType(given, type) : type;
+    return given.every((candidate) => matches(candidate, valueType)) ? undefined : MISMATCH;
+}

package/dist/analyze.js

@@ -1,7 +1,7 @@
 import { checkWarehouseSource } from "./warehouse-backed.js";
 import { Schema } from "effect";
 import { BLOB_UPLOAD_ANNOTATION } from "./blob.js";
-import { BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
+import { isBlobAccept, MAX_BLOB_BYTES } from "./blob.js";
 import { isAction } from "./action.js";
 import { CONNECTION_KEY, isConnection } from "./connection.js";
 import { isEntity } from "./entity.js";
@@ -411,12 +411,13 @@ function checkProperty(path, schema, definition, report) {
             report("invalid-property", path, "Blob properties cannot be unique or have a default.");
         }
         if (!definition.accept?.length ||
-            definition.accept.some((type) => !BLOB_CONTENT_TYPES.includes(type)) ||
-            new Set(definition.accept).size !== definition.accept.length ||
+            definition.accept.some((type) => !isBlobAccept(type)) ||
+            new Set(definition.accept.map((type) => type.toLowerCase())).size !==
+                definition.accept.length ||
             !Number.isInteger(definition.maxBytes) ||
             definition.maxBytes < 1 ||
             definition.maxBytes > MAX_BLOB_BYTES) {
-            report("invalid-constraint", path, "Use supported content types and a limit from 1 byte to 25 MiB.");
+            report("invalid-constraint", path, "Use MIME types or ranges and a limit from 1 byte to 25 MiB.");
         }
     }
     if (definition.type === "select") {

package/dist/authoring-records.d.ts

@@ -5,6 +5,11 @@ interface Definition {
     readonly properties: Properties;
     readonly relationships?: Relationships;
 }
+/**
+ * A select property's values as stored, the option values' wire names, or as authored when
+ * `decode`. Other properties' values are data and stay as they are.
+ */
+export declare function selectValue(value: unknown, property: unknown, decode: boolean): unknown;
 /** Only record keys and select identifiers convert; property values remain data. */
 export declare function recordFromWire<A>(value: unknown, definition?: Definition): A;
 export declare function valuesToWire(values: StoredValues, definition: Definition): StoredValues;

package/dist/authoring-records.js

@@ -6,7 +6,11 @@ function targetDefinition(target) {
     const resolved = typeof target === "function" ? target() : target;
     return isEntity(resolved) ? resolved.definition : undefined;
 }
-function selectValue(value, property, decode) {
+/**
+ * A select property's values as stored, the option values' wire names, or as authored when
+ * `decode`. Other properties' values are data and stay as they are.
+ */
+export function selectValue(value, property, decode) {
     const definition = propertyDefinition(property);
     if (definition?.type !== "select") {
         return value;

package/dist/authoring.js

@@ -2,6 +2,7 @@ import { Schema } from "effect";
 import { isAction } from "./action.js";
 import { actionInputToWire } from "./authoring-input.js";
 import { isRecord, nameToWire, permissionToWire } from "./authoring-names.js";
+import { selectValue } from "./authoring-records.js";
 import { isEntity } from "./entity.js";
 import { toCamelCase } from "./names.js";
 import { p, propertyDefinition } from "./property.js";
@@ -21,7 +22,29 @@ function indexToWire(index) {
     const definition = index;
     return { ...definition, properties: (definition.properties ?? []).map(nameToWire) };
 }
-function expressionToWire(value) {
+/**
+ * A measure condition with wire names: its property, as `property` or, in a `filtered` expression,
+ * `column`, and the values of a select property, which are option values.
+ */
+function conditionToWire(condition, properties) {
+    if (!isRecord(condition)) {
+        return condition;
+    }
+    const key = "property" in condition ? "property" : "column";
+    const name = condition[key];
+    if (typeof name !== "string") {
+        return condition;
+    }
+    const property = isRecord(properties) && Object.hasOwn(properties, name) ? properties[name] : undefined;
+    return {
+        ...condition,
+        [key]: nameToWire(name),
+        ...("value" in condition ? { value: selectValue(condition.value, property, false) } : {}),
+        ...("values" in condition ? { values: selectValue(condition.values, property, false) } : {}),
+    };
+}
+/** A measure expression with wire names: properties, measure references and conditions. */
+function expressionToWire(value, properties) {
     if (!isRecord(value)) {
         return value;
     }
@@ -30,7 +53,13 @@ function expressionToWire(value) {
         expression.name = nameToWire(value.name);
     }
     if (Array.isArray(value.args)) {
-        expression.args = value.args.map(expressionToWire);
+        expression.args = value.args.map((arg) => expressionToWire(arg, properties));
+    }
+    if (Array.isArray(value.where)) {
+        expression.where = value.where.map((condition) => conditionToWire(condition, properties));
+    }
+    if (typeof value.balanceOver === "string") {
+        expression.balanceOver = nameToWire(value.balanceOver);
     }
     return expression;
 }
@@ -141,7 +170,7 @@ class AuthoringEncoder {
             ...(original.measures === undefined
                 ? {}
                 : {
-                    measures: this.named(original.measures, `${entity.name}.measures`, (value) => expressionToWire(value)),
+                    measures: this.named(original.measures, `${entity.name}.measures`, (value) => expressionToWire(value, original.properties)),
                 }),
         };
         this.definitions.set(original, normalized);

package/dist/blob.d.ts

@@ -20,7 +20,14 @@ export declare const BlobUpload: Schema.Struct<{
 export type BlobUpload = typeof BlobUpload.Type;
 export declare const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
 export declare const MAX_BLOB_BYTES: number;
-export declare const BLOB_CONTENT_TYPES: readonly ["application/pdf", "image/jpeg", "image/png", "text/plain"];
+/** Common content types for file properties; any valid MIME type may be declared. */
+export declare const BLOB_CONTENT_TYPES: readonly ["application/pdf", "image/jpeg", "image/png", "text/plain", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.ms-excel", "text/csv", "text/tab-separated-values", "application/json", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/zip", "application/octet-stream"];
+/** A concrete MIME type, without wildcards, parameters or header control characters. */
+export declare function isBlobContentType(contentType: string): boolean;
+/** A property's MIME restriction: a concrete type, a type range, or all files. */
+export declare function isBlobAccept(accept: string): boolean;
+/** Omitted restrictions accept every concrete MIME type; an empty list accepts nothing. */
+export declare function acceptsBlobContentType(accept: ReadonlyArray<string> | undefined, contentType: string): boolean;
 type SchemaValue<S> = S extends {
     readonly Type: infer T;
 } ? T : S extends Schema.optionalKey<infer Inner> ? Inner["Type"] : never;

package/dist/blob.js

@@ -28,12 +28,46 @@ function uploadCodec(entity, property) {
 export const BlobUpload = Schema.Struct({ uploadId: Schema.String.check(Schema.isUUID()) });
 export const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
 export const MAX_BLOB_BYTES = 25 * 1024 * 1024;
+/** Common content types for file properties; any valid MIME type may be declared. */
 export const BLOB_CONTENT_TYPES = [
     "application/pdf",
     "image/jpeg",
     "image/png",
     "text/plain",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-excel",
+    "text/csv",
+    "text/tab-separated-values",
+    "application/json",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/zip",
+    "application/octet-stream",
 ];
+const CONTENT_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+const CONTENT_TYPE_RANGE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/\*$/i;
+/** A concrete MIME type, without wildcards, parameters or header control characters. */
+export function isBlobContentType(contentType) {
+    return contentType === contentType.trim() && CONTENT_TYPE.test(contentType);
+}
+/** A property's MIME restriction: a concrete type, a type range, or all files. */
+export function isBlobAccept(accept) {
+    return (accept === accept.trim() &&
+        (accept === "*/*" || CONTENT_TYPE_RANGE.test(accept) || isBlobContentType(accept)));
+}
+/** Omitted restrictions accept every concrete MIME type; an empty list accepts nothing. */
+export function acceptsBlobContentType(accept, contentType) {
+    if (!isBlobContentType(contentType)) {
+        return false;
+    }
+    const normalized = contentType.toLowerCase();
+    return (accept === undefined ||
+        accept.some((candidate) => {
+            const pattern = candidate.toLowerCase();
+            return (pattern === "*/*" ||
+                pattern === normalized ||
+                (CONTENT_TYPE_RANGE.test(pattern) && normalized.startsWith(pattern.slice(0, -1))));
+        }));
+}
 /** Internal wire codec for session tickets and generated action inputs. */
 export function uploadInput(entity, property) {
     return uploadCodec(entity, property);

package/dist/index.d.ts

@@ -2,7 +2,9 @@ export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } fr
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export type { WarehouseSource } from "./source.js";
 export { m } from "./measure.js";
-export type { Measure, Measures, MeasureExpression, MeasureOptions } from "./measure.js";
+export type { AggregateDeclarations, AggregateOptions, Measure, MeasureColumnCondition, MeasureCondition, Measures, MeasureExpression, MeasureOptions, } from "./measure.js";
+export { MEASURE_CONDITION_OPERATORS } from "./aggregate-filters.js";
+export type { AggregateValue, MeasureConditionOperator } from "./aggregate-filters.js";
 export { action, isAction } from "./action.js";
 export type { Action, ActionConfig, ActionConfigWithConnections, ActionContext, ActionEncodedInput, ActionHints, ActionInput, ActionResult, Actions, AnyAction, PrepareContext, PrepareError, } from "./action.js";
 export { CONNECTION_ERROR_REASONS, CONNECTION_KEY, CONNECTION_METHODS, connection, ConnectionError, Connections, ConnectionTransport, isConnection, MAXIMUM_CONNECTION_BODY_BYTES, } from "./connection.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export { m } from "./measure.js";
+export { MEASURE_CONDITION_OPERATORS } from "./aggregate-filters.js";
 export { action, isAction } from "./action.js";
 export { CONNECTION_ERROR_REASONS, CONNECTION_KEY, CONNECTION_METHODS, connection, ConnectionError, Connections, ConnectionTransport, isConnection, MAXIMUM_CONNECTION_BODY_BYTES, } from "./connection.js";
 export { Diagnostic, DIAGNOSTIC_CODES, formatDiagnostics, InvalidOntology } from "./diagnostics.js";