@sixb/core 0.0.1

package/dist/ontology/units/quantitative-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantitative-types.d.ts","sourceRoot":"","sources":["../../../src/ontology/units/quantitative-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAgFH,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2euB,CAAA;AAMrD,sEAAsE;AACtE,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAE/D;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,kBAAkB,IAAI,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;AAEhG,4DAA4D;AAC5D,MAAM,MAAM,MAAM,GAAG;KAClB,CAAC,IAAI,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;CACtC,CAAC,kBAAkB,CAAC,CAAA"}

package/dist/ontology/units/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core interfaces for the quantitative types system.
+ *
+ * Two layers model physical quantities:
+ * - **Unit** — a specific unit of measurement (e.g. degree Celsius).
+ * - **QuantitativeType** — a physical quantity with its valid units (e.g. Temperature).
+ *
+ * Inspired by Azure DTDL QuantitativeTypes v2.
+ */
+/** A specific unit of measurement. */
+export interface Unit {
+    /** Human-readable name, e.g. "Degree Celsius". */
+    readonly name: string;
+    /** Display symbol, e.g. "°C". */
+    readonly symbol: string;
+}
+/** A physical quantity or measurement concept with its valid units. */
+export interface QuantitativeType {
+    /** Human-readable name, e.g. "Temperature". */
+    readonly name: string;
+    /** Description of what this quantity measures. */
+    readonly description: string;
+    /** Valid units for this quantity, keyed by unit id. */
+    readonly units: Record<string, Unit>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ontology/units/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ontology/units/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,sCAAsC;AACtC,MAAM,WAAW,IAAI;IACnB,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CACrC"}

package/dist/ontology/validation/index.d.ts

@@ -0,0 +1,7 @@
+export { assertLinkTargetType, assertTargetTypeCompatible, normalizeLinkProperties, validateLinkProperties, } from "./links";
+export { coerceSchemaValueToTyped, normalizeObjectProperties, normalizeSchemaValue, } from "./normalize";
+export { assertKnownProperties, assertLinkTokenBelongsToObjectType, assertObjectTypeRegistered, assertPropertyTokenBelongsToObjectType, assertRequiredProperties, validateObjectProperties, validatePrimaryProperties, validatePropertyDefinitions, validatePropertyValue, } from "./properties";
+export { validateQueryMetadata } from "./query";
+export { isRecord, resolveValueTypeRef, resolveValueTypeSchema, validateSchemaValue, } from "./schema";
+export { assertTelemetryProperty, resolveSemanticType, validateTelemetryUnit, } from "./telemetry";
+//# sourceMappingURL=index.d.ts.map

package/dist/ontology/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,qBAAqB,EACrB,kCAAkC,EAClC,0BAA0B,EAC1B,sCAAsC,EACtC,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,GACtB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,UAAU,CAAA;AAEjB,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,aAAa,CAAA"}

package/dist/ontology/validation/links.d.ts

@@ -0,0 +1,18 @@
+import type { JsonValue } from "../../json";
+import type { ObjectLink, ValueType } from "..";
+import type { ObjectTypeWithPropertyTokens } from "../tokens";
+/**
+ * Assert that `targetTypeId` is compatible with the link definition's declared target.
+ *
+ * When `isValidLinkTarget` is provided (e.g. for polymorphic subtype checks),
+ * it is used instead of strict equality.
+ */
+export declare function assertLinkTargetType(objectTypeId: string, linkId: string, linkDefinition: ObjectLink, targetTypeId: string, isValidLinkTarget?: (expected: string | string[], actual: string) => boolean): void;
+/**
+ * Verify that `actualTarget` is either the same as or a subtype of the
+ * link's declared `targetObjectTypeId`. Throws on mismatch.
+ */
+export declare function assertTargetTypeCompatible(getSubTypes: (typeId: string) => string[], declaredTarget: string | string[], actualTarget: string, context: string): void;
+export declare function normalizeLinkProperties(objectType: ObjectTypeWithPropertyTokens, link: ObjectLink, properties: Readonly<Record<string, unknown>> | undefined, valueTypesById: ReadonlyMap<string, ValueType>): Record<string, JsonValue> | undefined;
+export declare function validateLinkProperties(objectType: ObjectTypeWithPropertyTokens, link: ObjectLink, properties: Record<string, unknown> | undefined, existingProperties: Record<string, unknown> | undefined, valueTypesById: ReadonlyMap<string, ValueType>): void;
+//# sourceMappingURL=links.d.ts.map

package/dist/ontology/validation/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AAE/C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAA;AAI7D;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,UAAU,EAC1B,YAAY,EAAE,MAAM,EACpB,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,GAC3E,IAAI,CAYN;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,EAAE,EACzC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,EACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GACd,IAAI,CAWN;AAED,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,4BAA4B,EACxC,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EACzD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,SAAS,CAQvC;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,4BAA4B,EACxC,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC/C,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACvD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAiDN"}

package/dist/ontology/validation/normalize.d.ts

@@ -0,0 +1,21 @@
+import { type JsonValue } from "../../json";
+import type { Property, Schema, ValueType } from "..";
+/**
+ * Normalize a property bag to JSON-safe values using each property's schema —
+ * notably converting `Date` to an ISO string for `date`/`timestamp` props.
+ * Unknown properties are skipped; `null` passes through unchanged.
+ *
+ * Shared by the object upsert and edit paths so both emit the same serializable
+ * shape; the typed surface accepts `Date | string`, the wire stores strings.
+ */
+export declare function normalizeObjectProperties(definitions: readonly Property[], properties: Readonly<Record<string, unknown>>, valueTypesById: ReadonlyMap<string, ValueType>, path: string): Record<string, JsonValue>;
+export declare function normalizeSchemaValue(schema: Schema, value: unknown, path: string, valueTypesById: ReadonlyMap<string, ValueType>): JsonValue;
+/**
+ * Inverse of `normalizeSchemaValue` for the handler-facing surface: re-hydrate
+ * `date`/`timestamp` values from their stored ISO string back into a `Date`, so
+ * a handler receives the `Date` its types promise. Other scalars pass through;
+ * arrays, maps, objects, and value-type refs recurse. The input is assumed to be
+ * already validated/normalized JSON, so this is permissive and never throws.
+ */
+export declare function coerceSchemaValueToTyped(schema: Schema, value: unknown, valueTypesById: ReadonlyMap<string, ValueType>): unknown;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/ontology/validation/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,KAAK,EAAqB,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AAKxE;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,QAAQ,EAAE,EAChC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC7C,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAC9C,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAW3B;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,SAAS,CA+DX;AAuDD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,OAAO,CAgDT"}

package/dist/ontology/validation/properties.d.ts

@@ -0,0 +1,19 @@
+import type { ObjectLink, ObjectType, Property, ValueType } from "..";
+import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../tokens";
+export declare function assertObjectTypeRegistered(objectTypesById: ReadonlyMap<string, ObjectTypeWithPropertyTokens>, objectType: ObjectTypeWithPropertyTokens): void;
+export declare function assertPropertyTokenBelongsToObjectType(objectType: ObjectTypeWithPropertyTokens, property: PropertyToken<string, string, Property>): void;
+export declare function assertLinkTokenBelongsToObjectType(objectType: ObjectTypeWithPropertyTokens, link: unknown): asserts link is LinkToken<string, string, string | readonly string[], ObjectLink>;
+export declare function assertKnownProperties(objectType: ObjectTypeWithPropertyTokens, properties: Record<string, unknown>): void;
+export declare function assertRequiredProperties(objectType: ObjectTypeWithPropertyTokens, properties: Record<string, unknown>): void;
+/** Runtime validation protects callers even when TypeScript checks are bypassed. */
+export declare function validateObjectProperties(objectType: ObjectTypeWithPropertyTokens, properties: Record<string, unknown>, valueTypesById: ReadonlyMap<string, ValueType>): void;
+/**
+ * Validate that every registered object type has exactly one primary property
+ * that is required and has schema "string".
+ *
+ * Returns a Map<objectTypeId, primaryPropertyId> for runtime derivation.
+ */
+export declare function validatePrimaryProperties(objectTypesById: ReadonlyMap<string, ObjectType>): Map<string, string>;
+export declare function validatePropertyDefinitions(objectTypesById: ReadonlyMap<string, ObjectType>, valueTypesById: ReadonlyMap<string, ValueType>): void;
+export declare function validatePropertyValue(property: Property, value: unknown, path: string, valueTypesById: ReadonlyMap<string, ValueType>): void;
+//# sourceMappingURL=properties.d.ts.map

package/dist/ontology/validation/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/properties.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAU,SAAS,EAAE,MAAM,IAAI,CAAA;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAGvF,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,4BAA4B,CAAC,EAClE,UAAU,EAAE,4BAA4B,GACvC,IAAI,CAMN;AAED,wBAAgB,sCAAsC,CACpD,UAAU,EAAE,4BAA4B,EACxC,QAAQ,EAAE,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,GAChD,IAAI,CAMN;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,4BAA4B,EACxC,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,IAAI,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAAE,UAAU,CAAC,CAYnF;AAgCD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,4BAA4B,EACxC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CASN;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,4BAA4B,EACxC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAQN;AAED,oFAAoF;AACpF,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,4BAA4B,EACxC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAQN;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAC/C,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCrB;AAED,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAChD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAWN;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAaN"}

package/dist/ontology/validation/query.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectType, ValueType } from "..";
+export declare function validateQueryMetadata(objectTypesById: ReadonlyMap<string, ObjectType>, valueTypesById: ReadonlyMap<string, ValueType>): void;
+//# sourceMappingURL=query.d.ts.map

package/dist/ontology/validation/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoB,SAAS,EAAE,MAAM,IAAI,CAAA;AAcjE,wBAAgB,qBAAqB,CACnC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAChD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAYN"}

package/dist/ontology/validation/schema.d.ts

@@ -0,0 +1,7 @@
+import type { Schema, ValueType, ValueTypeRefSchema } from "..";
+/** Recursive schema validator used by both object and link property validation. */
+export declare function validateSchemaValue(schema: Schema, value: unknown, path: string, valueTypesById: ReadonlyMap<string, ValueType>): void;
+export declare function resolveValueTypeRef(schema: Schema): string | undefined;
+export declare function resolveValueTypeSchema(schema: ValueTypeRefSchema, valueTypesById: ReadonlyMap<string, ValueType>, path: string): Schema;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/ontology/validation/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAqB,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAA;AAIlF,mFAAmF;AACnF,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAoHN;AAkBD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAUtE;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAC9C,IAAI,EAAE,MAAM,GACX,MAAM,CAQR;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/dist/ontology/validation/telemetry.d.ts

@@ -0,0 +1,7 @@
+import type { Property, ValueType } from "..";
+import type { QuantitativeTypeId } from "../units";
+export declare function assertTelemetryProperty(property: Property): void;
+export declare function resolveSemanticType(property: Property, valueTypesById: ReadonlyMap<string, ValueType>): QuantitativeTypeId | undefined;
+/** Validates that unit is present/absent based on semantic type, and that it's a valid unit. */
+export declare function validateTelemetryUnit(property: Property, propertyPath: string, unit: string | undefined, valueTypesById: ReadonlyMap<string, ValueType>): void;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/ontology/validation/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../../src/ontology/validation/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AAE7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAIlD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAIhE;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,kBAAkB,GAAG,SAAS,CAWhC;AAED,gGAAgG;AAChG,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAC7C,IAAI,CAkBN"}

package/dist/pipelines/builders.d.ts

@@ -0,0 +1,14 @@
+import type { PipelineBuilder, PipelineStepInputBuilder } from "./types";
+/**
+ * Define one dataset transform step.
+ *
+ * The returned definition is inert until referenced by a pipeline definition.
+ */
+export declare function definePipelineStep<TId extends string>(id: TId): PipelineStepInputBuilder<TId>;
+/**
+ * Define a sequential pipeline that composes dataset transform steps.
+ *
+ * The returned definition is inert and safe to export from `pipelines/` modules.
+ */
+export declare function definePipeline<TId extends string>(id: TId): PipelineBuilder<TId>;
+//# sourceMappingURL=builders.d.ts.map

package/dist/pipelines/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/pipelines/builders.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EAKf,wBAAwB,EAIzB,MAAM,SAAS,CAAA;AA+DhB;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,SAAS,MAAM,EAAE,EAAE,EAAE,GAAG,GAAG,wBAAwB,CAAC,GAAG,CAAC,CAmD7F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,SAAS,MAAM,EAAE,EAAE,EAAE,GAAG,GAAG,eAAe,CAAC,GAAG,CAAC,CAYhF"}

package/dist/pipelines/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class PipelineError extends Error {
+    readonly name = "PipelineError";
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/pipelines/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/pipelines/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,mBAAkB;CAChC"}

package/dist/pipelines/index.d.ts

@@ -0,0 +1,7 @@
+export { definePipeline, definePipelineStep } from "./builders";
+export { PipelineError } from "./errors";
+export type { PipelineRunRequestOptions, PipelineRunRequestResult, RequestPipelineRunInput, } from "./request";
+export { requestPipelineRun } from "./request";
+export type { PipelineBuilder, PipelineDefinition, PipelineGraph, PipelineSequenceGraph, PipelineStepDefinition, PipelineStepExecutor, PipelineStepExecutorBuilder, PipelineStepInput, PipelineStepInputBuilder, PipelineStepNode, PipelineStepOutput, PipelineStepOutputBuilder, PipelineStepOutputOptions, PipelineStepRunContext, PipelineStepRunHandler, } from "./types";
+export { isPipelineDefinition, isPipelineStepDefinition } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipelines/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,YAAY,EACV,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC9C,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,2BAA2B,EAC3B,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA"}

package/dist/pipelines/request.d.ts

@@ -0,0 +1,31 @@
+import type { SixbRuntimeContext } from "../runtime/types";
+import type { PipelineDefinition } from "./types";
+export interface PipelineRunRequestOptions {
+    /**
+     * Identity of the run to create. Deduplicated when a worker claims the job, not here: two requests
+     * carrying the same id enqueue two jobs, and the second loses to the unique run id. So one run
+     * happens, but this call cannot tell you whether it was yours.
+     */
+    readonly runId?: string;
+}
+export interface RequestPipelineRunInput extends PipelineRunRequestOptions {
+    readonly pipelineId: string;
+}
+export interface PipelineRunRequestResult {
+    readonly pipelineId: string;
+    readonly runId: string;
+    /** When the job was enqueued. Not persisted — the run row records `startedAt` instead. */
+    readonly queuedAt: string;
+    readonly jobId?: string;
+}
+/**
+ * Authorize and queue a pipeline run request.
+ *
+ * Operates on an already-resolved definition and the shared runtime context, so the HTTP route and
+ * the runtime verb cannot drift apart.
+ *
+ * Like `requestSyncRun` and unlike `requestWorkflowRun`, the run row is created by the worker that
+ * claims the job — see the note there for why the two cannot be aligned by adding a field.
+ */
+export declare function requestPipelineRun(runtime: SixbRuntimeContext, pipeline: PipelineDefinition, options?: PipelineRunRequestOptions): Promise<PipelineRunRequestResult>;
+//# sourceMappingURL=request.d.ts.map

package/dist/pipelines/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/pipelines/request.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,uBAAwB,SAAQ,yBAAyB;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,wBAAwB,CAAC,CAmBnC"}

package/dist/pipelines/types.d.ts

@@ -0,0 +1,84 @@
+import type { DatasetDefinition } from "../datasets";
+import type { DatasetRow, DatasetVersion, DatasetWriteMode, ReadDatasetRowsInput } from "../lake-storage";
+import { type SqlDialect, type SqlTransformBody } from "../lake-storage/sql-transforms";
+import type { Logger } from "../logging";
+import type { ScheduleDefinition, ScheduleReference } from "../schedules";
+export type PipelineStepExecutor = {
+    readonly kind: "sql";
+    readonly dialect: SqlDialect;
+    readonly sql: SqlTransformBody<SqlDialect>;
+} | {
+    readonly kind: "run";
+    readonly handler: PipelineStepRunHandler;
+};
+export interface PipelineStepInput {
+    readonly dataset: DatasetDefinition;
+    readonly version: DatasetVersion;
+    readRows(input?: Omit<ReadDatasetRowsInput, "datasetId" | "versionId">): AsyncIterable<DatasetRow>;
+}
+export interface PipelineStepOutput {
+    writeRows(rows: Iterable<DatasetRow> | AsyncIterable<DatasetRow>): Promise<void>;
+}
+export interface PipelineStepRunContext<TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>> {
+    readonly projectId: string;
+    readonly pipelineId: string;
+    readonly stepId: string;
+    readonly runId: string;
+    readonly signal: AbortSignal;
+    readonly inputs: {
+        readonly [K in keyof TInputs]: PipelineStepInput;
+    };
+    readonly output: PipelineStepOutput;
+    readonly logger: Logger;
+}
+export type PipelineStepRunHandler<TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>> = (ctx: PipelineStepRunContext<TInputs>) => Promise<void> | void;
+export interface PipelineStepDefinition<TId extends string = string, TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>> {
+    readonly kind: "pipeline.step";
+    readonly id: TId;
+    readonly inputs: Readonly<TInputs>;
+    readonly output: DatasetDefinition;
+    readonly mode: DatasetWriteMode;
+    readonly executor: PipelineStepExecutor;
+}
+export interface PipelineStepNode {
+    readonly kind: "step";
+    readonly step: PipelineStepDefinition;
+}
+export interface PipelineSequenceGraph {
+    readonly kind: "sequence";
+    readonly nodes: readonly PipelineStepNode[];
+}
+export type PipelineGraph = PipelineSequenceGraph;
+/**
+ * Inert pipeline definition registered with Sixb.
+ *
+ * V1 executes a single sequential graph. The graph shape leaves room for
+ * parallel nodes later without changing step definitions.
+ */
+export interface PipelineDefinition<TId extends string = string> {
+    readonly kind: "pipeline";
+    readonly id: TId;
+    readonly triggers: readonly ScheduleReference[];
+    readonly graph: PipelineGraph;
+}
+export interface PipelineStepInputBuilder<TId extends string = string> {
+    inputs<TInputs extends Record<string, DatasetDefinition>>(inputs: TInputs): PipelineStepOutputBuilder<TId, TInputs>;
+}
+export interface PipelineStepOutputBuilder<TId extends string = string, TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>> {
+    output(dataset: DatasetDefinition, options?: PipelineStepOutputOptions): PipelineStepExecutorBuilder<TId, TInputs>;
+}
+export interface PipelineStepExecutorBuilder<TId extends string = string, TInputs extends Record<string, DatasetDefinition> = Record<string, DatasetDefinition>> {
+    run(handler: PipelineStepRunHandler<TInputs>): PipelineStepDefinition<TId, TInputs>;
+    sql(sql: SqlTransformBody<SqlDialect>): PipelineStepDefinition<TId, TInputs>;
+}
+export interface PipelineStepOutputOptions {
+    readonly mode?: DatasetWriteMode;
+}
+export interface PipelineBuilder<TId extends string = string> extends PipelineDefinition<TId> {
+    when(schedule: ScheduleDefinition): PipelineBuilder<TId>;
+    then(step: PipelineStepDefinition): PipelineBuilder<TId>;
+}
+/** Runtime type guard for values discovered from `pipelines/` modules. */
+export declare function isPipelineDefinition(value: unknown): value is PipelineDefinition;
+export declare function isPipelineStepDefinition(value: unknown): value is PipelineStepDefinition;
+//# sourceMappingURL=types.d.ts.map

package/dist/pipelines/types.d.ts.map

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

package/dist/predicates/builders.d.ts

@@ -0,0 +1,24 @@
+import type { FieldPredicate, LinkPredicateBuilder, Predicate, PredicateValue, PropertyPredicate, PropertyPredicateOperator } from "./types";
+export type RuntimePropertyPredicateBuilder<TResult = PropertyPredicate> = {
+    eq(value: PredicateValue): TResult;
+    notEq(value: PredicateValue): TResult;
+    gt(value: PredicateValue): TResult;
+    gte(value: PredicateValue): TResult;
+    lt(value: PredicateValue): TResult;
+    lte(value: PredicateValue): TResult;
+    isPresent(): TResult;
+    isMissing(): TResult;
+};
+export declare function createFieldPredicate(field: string, value: PredicateValue, options?: Pick<PropertyPredicateBuilderOptions<unknown>, "subject" | "createError">): FieldPredicate;
+export type PropertyPredicateBuilderOptions<TResult> = {
+    readonly subject?: string;
+    readonly createError?: (message: string) => Error;
+    readonly wrap?: (predicate: PropertyPredicate) => TResult;
+};
+export declare function createPropertyPredicate(propertyId: string, op: PropertyPredicateOperator, value?: PredicateValue, options?: Pick<PropertyPredicateBuilderOptions<unknown>, "subject" | "createError">): PropertyPredicate;
+export declare function createPropertyPredicateBuilder<TResult = PropertyPredicate>(propertyId: string, options?: PropertyPredicateBuilderOptions<TResult>): RuntimePropertyPredicateBuilder<TResult>;
+export declare function createLinkPredicateBuilder(linkId: string): LinkPredicateBuilder;
+export declare function allPredicates(predicates: readonly Predicate[]): Predicate;
+export declare function anyPredicates(predicates: readonly Predicate[]): Predicate;
+export declare function notPredicate(predicate: Predicate): Predicate;
+//# sourceMappingURL=builders.d.ts.map

package/dist/predicates/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/predicates/builders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,SAAS,CAAA;AAGhB,MAAM,MAAM,+BAA+B,CAAC,OAAO,GAAG,iBAAiB,IAAI;IACzE,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IAClC,KAAK,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IACrC,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IAClC,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IACnC,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IAClC,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAA;IACnC,SAAS,IAAI,OAAO,CAAA;IACpB,SAAS,IAAI,OAAO,CAAA;CACrB,CAAA;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,cAAc,EACrB,OAAO,GAAE,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,aAAa,CAAM,GACtF,cAAc,CAShB;AAED,MAAM,MAAM,+BAA+B,CAAC,OAAO,IAAI;IACrD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,KAAK,CAAA;IACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,OAAO,CAAA;CAC1D,CAAA;AAgBD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,yBAAyB,EAC7B,KAAK,CAAC,EAAE,cAAc,EACtB,OAAO,GAAE,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,aAAa,CAAM,GACtF,iBAAiB,CAanB;AAED,wBAAgB,8BAA8B,CAAC,OAAO,GAAG,iBAAiB,EACxE,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,+BAA+B,CAAC,OAAO,CAAM,GACrD,+BAA+B,CAAC,OAAO,CAAC,CA+B1C;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAiB/E;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAKzE;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAKzE;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAK5D"}

package/dist/predicates/evaluate.d.ts

@@ -0,0 +1,8 @@
+import type { Predicate } from "./types";
+export interface PredicateEvaluationSubject {
+    readonly properties?: Readonly<Record<string, unknown>>;
+    readonly fields?: Readonly<Record<string, unknown>>;
+    readonly links?: Readonly<Record<string, boolean>>;
+}
+export declare function evaluatePredicate(predicate: Predicate, subject: PredicateEvaluationSubject): boolean;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/predicates/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/predicates/evaluate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,SAAS,EAGV,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACnD;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAeT"}

package/dist/predicates/index.d.ts

@@ -0,0 +1,5 @@
+export { allPredicates, anyPredicates, createFieldPredicate, createLinkPredicateBuilder, createPropertyPredicate, createPropertyPredicateBuilder, notPredicate, type RuntimePropertyPredicateBuilder, } from "./builders";
+export { evaluatePredicate, type PredicateEvaluationSubject } from "./evaluate";
+export type { AllPredicate, AnyPredicate, FieldPredicate, LinkPredicate, LinkPredicateBuilder, LinkPredicateOperator, NotPredicate, OrderedPredicateValueFor, Predicate, PredicateValue, PredicateValueFor, PropertyPredicate, PropertyPredicateBuilder, PropertyPredicateOperator, } from "./types";
+export { assertPredicateShape, isPredicateValue } from "./validation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/predicates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,8BAA8B,EAC9B,YAAY,EACZ,KAAK,+BAA+B,GACrC,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,iBAAiB,EAAE,KAAK,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAC/E,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,YAAY,EACZ,wBAAwB,EACxB,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA"}

package/dist/predicates/types.d.ts

@@ -0,0 +1,69 @@
+import type { DecimalValue } from "../ontology/decimal";
+import type { Property, Schema } from "../ontology/types";
+export type Predicate = AllPredicate | AnyPredicate | NotPredicate | PropertyPredicate | FieldPredicate | LinkPredicate;
+export interface AllPredicate {
+    readonly kind: "all";
+    readonly predicates: readonly Predicate[];
+}
+export interface AnyPredicate {
+    readonly kind: "any";
+    readonly predicates: readonly Predicate[];
+}
+export interface NotPredicate {
+    readonly kind: "not";
+    readonly predicate: Predicate;
+}
+export type PropertyPredicateOperator = "eq" | "notEq" | "gt" | "gte" | "lt" | "lte" | "isPresent" | "isMissing";
+export interface PropertyPredicate {
+    readonly kind: "property";
+    readonly propertyId: string;
+    readonly op: PropertyPredicateOperator;
+    readonly value?: PredicateValue;
+}
+export interface FieldPredicate {
+    readonly kind: "field";
+    readonly field: string;
+    readonly op: "eq";
+    readonly value: PredicateValue;
+}
+export type LinkPredicateOperator = "exists" | "isMissing";
+export interface LinkPredicate {
+    readonly kind: "link";
+    readonly linkId: string;
+    readonly op: LinkPredicateOperator;
+}
+export type PredicateValue = string | number | boolean | null;
+/** Serializable equality value inferred from a concrete ontology property. */
+export type PredicateValueFor<TProperty extends Property> = string extends TProperty["id"] ? PredicateValue : TProperty["nullable"] extends true ? SerializableSchemaPredicateValue<TProperty["schema"]> | null : SerializableSchemaPredicateValue<TProperty["schema"]>;
+type SerializableSchemaPredicateValue<TSchema extends Schema> = TSchema extends "string" | "uuid" | "date" | "timestamp" ? string : TSchema extends "integer" | "double" ? number : TSchema extends "decimal" ? DecimalValue : TSchema extends "boolean" ? boolean : TSchema extends {
+    readonly type: "enum";
+    readonly values: readonly (infer TValue)[];
+} ? Extract<TValue, PredicateValue> : TSchema extends {
+    readonly type: "valueTypeRef";
+    readonly _resolved: infer TResolved extends Schema;
+} ? SerializableSchemaPredicateValue<TResolved> : never;
+type OrderedSchemaPredicateValue<TSchema extends Schema> = TSchema extends "decimal" ? DecimalValue : TSchema extends "integer" | "double" ? number : TSchema extends {
+    readonly type: "enum";
+    readonly valueType: "integer";
+} ? number : TSchema extends {
+    readonly type: "valueTypeRef";
+    readonly _resolved: infer TResolved extends Schema;
+} ? OrderedSchemaPredicateValue<TResolved> : never;
+/** Ordered comparison value inferred from a concrete numeric ontology property. */
+export type OrderedPredicateValueFor<TProperty extends Property> = string extends TProperty["id"] ? number | DecimalValue : OrderedSchemaPredicateValue<TProperty["schema"]>;
+export interface PropertyPredicateBuilder<TProperty extends Property = Property, TResult = PropertyPredicate> {
+    eq(value: PredicateValueFor<TProperty>): TResult;
+    notEq(value: PredicateValueFor<TProperty>): TResult;
+    gt(value: OrderedPredicateValueFor<TProperty>): TResult;
+    gte(value: OrderedPredicateValueFor<TProperty>): TResult;
+    lt(value: OrderedPredicateValueFor<TProperty>): TResult;
+    lte(value: OrderedPredicateValueFor<TProperty>): TResult;
+    isPresent(): TResult;
+    isMissing(): TResult;
+}
+export interface LinkPredicateBuilder<_TLink = unknown> {
+    exists(): LinkPredicate;
+    isMissing(): LinkPredicate;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/predicates/types.d.ts.map

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

package/dist/predicates/validation.d.ts

@@ -0,0 +1,15 @@
+import type { Predicate, PredicateValue } from "./types";
+type AssertPredicateShapeOptions = {
+    readonly subject?: string;
+    readonly createError?: (message: string) => Error;
+};
+export declare function isPredicateValue(value: unknown): value is PredicateValue;
+/**
+ * Validate the portable predicate AST shape.
+ *
+ * Primitive-specific validators can wrap this with their own `subject` so
+ * errors read as "Rule ..." or "Trigger ..." while sharing the same checks.
+ */
+export declare function assertPredicateShape(value: unknown, options?: AssertPredicateShapeOptions): asserts value is Predicate;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/predicates/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/predicates/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,SAAS,EACT,cAAc,EAEf,MAAM,SAAS,CAAA;AAwBhB,KAAK,2BAA2B,GAAG;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,KAAK,CAAA;CAClD,CAAA;AAoBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAUxE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,KAAK,IAAI,SAAS,CA8E5B"}