@sixb/core 0.0.1

package/dist/ontology/types.d.ts

@@ -0,0 +1,402 @@
+/**
+ * Core schema language for ontology modeling.
+ *
+ * In Sixb, an Object Type ontology is built from:
+ * - scalar values (for simple facts),
+ * - structured values (for nested records), and
+ * - links (for relationships between object types).
+ *
+ * This file defines the value-shape side of that model.
+ */
+import type { QuantitativeTypeId } from "./units";
+/**
+ * Atomic scalar values used by properties and nested fields.
+ *
+ * Use these for facts that do not need internal structure.
+ *
+ * Examples:
+ * - `"string"` for a display name.
+ * - `"uuid"` for an external system identifier.
+ * - `"timestamp"` for `lastObservedAt`.
+ * - `"fileRef"` for blob-backed documents, images, and attachments.
+ * - `"double"` for telemetry such as temperature or humidity.
+ */
+export type PrimitiveSchema = "string" | "integer" | "double" | "decimal" | "boolean" | "date" | "timestamp" | "uuid" | "fileRef";
+export interface ValueTypeRefSchema {
+    type: "valueTypeRef";
+    valueTypeId: string;
+    /** Type-level: fully resolved schema for direct inference. Populated by codegen. */
+    _resolved?: Schema;
+}
+/**
+ * Enumeration of allowed values.
+ *
+ * Use this when the domain is finite and explicit.
+ *
+ * Examples:
+ * - HVAC mode: `{ type: "enum", valueType: "string", values: ["off", "heat", "cool", "auto"] }`
+ * - Fan speed level: `{ type: "enum", valueType: "integer", values: [1, 2, 3] }`
+ */
+export type EnumSchema = {
+    type: "enum";
+    valueType: "string";
+    values: string[];
+} | {
+    type: "enum";
+    valueType: "integer";
+    values: number[];
+};
+/**
+ * Field definition inside an inline object schema.
+ *
+ * `required` and `nullable` mirror top-level `Property` semantics:
+ * - `required: true` means the field must be present.
+ * - `nullable: true` means the field may be present with `null` value.
+ */
+export interface ObjectFieldSchema {
+    description?: string;
+    required?: boolean;
+    /**
+     * Physical quantity this field measures.
+     *
+     * Constrains which units are valid for this field's values.
+     * Only meaningful when `schema` is a numeric type (`"double"`, `"integer"`, `"decimal"`).
+     *
+     * @example `semanticType: "Temperature"` — allows `degreeCelsius`, `degreeFahrenheit`, `kelvin`
+     */
+    semanticType?: QuantitativeTypeId;
+    nullable?: boolean;
+    schema: Schema;
+}
+/**
+ * Structured object with named fields.
+ *
+ * Example: a `temperatureRange` property with min and max fields,
+ * both constrained to temperature units via `semanticType`.
+ *
+ * ```ts
+ * {
+ *   type: "object",
+ *   properties: {
+ *     min: { required: true, schema: "double", semanticType: "Temperature" },
+ *     max: { required: true, schema: "double", semanticType: "Temperature" },
+ *     value: { required: true, schema: "double" },
+ *     unit: { required: true, schema: { type: "enum", valueType: "string", values: ["C", "F"] } }
+ *   }
+ * }
+ * ```
+ */
+export interface ObjectSchema {
+    type: "object";
+    properties: Record<string, ObjectFieldSchema>;
+}
+/**
+ * Ordered collection of values.
+ *
+ * Use when order matters or duplicates are allowed.
+ *
+ * Examples:
+ * - A sequence of fault codes sorted by recency.
+ * - A list of related sensor ids: `{ type: "array", items: "uuid" }`.
+ */
+export interface ArraySchema {
+    type: "array";
+    items: Schema;
+}
+/**
+ * Key/value dictionary for dynamic or sparse attributes.
+ *
+ * `keySchema` is currently string-only, which fits most metadata maps.
+ * `valueSchema` may be scalar or nested.
+ *
+ * Example:
+ * `{ type: "map", keySchema: "string", valueSchema: "double" }`
+ * for a map like `{ "phaseA": 12.3, "phaseB": 11.9 }`.
+ */
+export interface MapSchema {
+    type: "map";
+    keySchema: "string";
+    valueSchema: Schema;
+}
+/**
+ * Recursive schema unions that enable deep composition.
+ *
+ * A `Schema` can be:
+ * - a primitive,
+ * - an enum/object/array/map,
+ * - or a reference to a reusable `ValueType`.
+ */
+export type ComplexSchema = ObjectSchema | ArraySchema | MapSchema | EnumSchema;
+export type Schema = PrimitiveSchema | ComplexSchema | ValueTypeRefSchema;
+/**
+ * Reusable named value contract.
+ *
+ * Use `ValueType` when multiple properties share the same semantic shape.
+ * ```ts
+ * {
+ *   id: "temperatureReading",
+ *   name: "Temperature Reading",
+ *   schema: "double",
+ *   semanticType: "Temperature",
+ * }
+ * ```
+ *
+ * Then reference it from properties via `ValueTypeRefSchema` to keep
+ * ontology definitions consistent and easier to evolve.
+ */
+export interface ValueType {
+    id: string;
+    name: string;
+    description?: string;
+    schema: Schema;
+    /**
+     * Physical quantity this value type measures.
+     *
+     * When set, any property referencing this value type inherits the constraint,
+     * and only units belonging to this quantity are valid.
+     */
+    semanticType?: QuantitativeTypeId;
+}
+/**
+ * Query/indexing metadata for an object or link property.
+ *
+ * `searchable` is the opt-in gate. More specific flags describe which query
+ * surfaces may use the property once a storage provider supports them.
+ */
+export interface PropertyQueryMetadata {
+    /** Enables the property for query indexing. Required when any specific flag is set. */
+    searchable?: boolean;
+    /** Enables property predicates such as equality/range filters. */
+    filterable?: boolean;
+    /** Enables deterministic ordering by this property. */
+    sortable?: boolean;
+    /** Enables keyword search over this property. String-like schemas only. */
+    text?: boolean;
+    /** Enables exact-match search over this property. */
+    exact?: boolean;
+    /** Enables faceting/grouping in search results. */
+    facet?: boolean;
+    /** Enables vector search when the property stores numeric embedding arrays. */
+    vector?: boolean;
+    /** Relative text-search weight. Only meaningful with `text: true`. */
+    weight?: number;
+}
+/**
+ * Object-level search profile.
+ *
+ * Search profiles decide which fields a global or type-scoped search uses.
+ * Primary ids remain exact-matchable even if omitted here.
+ */
+export interface ObjectTypeSearchMetadata {
+    /** Display/title property used in search results. */
+    title?: string;
+    /** Default keyword-search fields for this object type. */
+    defaultText?: readonly string[];
+    /** Exact-match fields such as external ids, slugs, or emails. */
+    exact?: readonly string[];
+    /** Vector-search configuration for semantic retrieval. */
+    vector?: {
+        /** Property that stores the embedding vector. */
+        property: string;
+        /** Source text properties used to produce the embedding. */
+        source: readonly string[];
+    };
+}
+/**
+ * Attribute on an `ObjectType` (or on a relationship via `ObjectLink.properties`).
+ * - `serialNumber` (string)
+ * - `manufacturer` (string)
+ * - `currentTemperature` (double, semanticType: "Temperature")
+ *
+ * Use `semanticType` to declare what physical quantity a numeric property
+ * measures. This constrains which units are valid for the property's values.
+ *
+ * ```ts
+ * {
+ *   id: "currentTemperature",
+ *   name: "Current Temperature",
+ *   schema: "double",
+ *   semanticType: "Temperature", // only Temperature units are valid
+ * }
+ * ```
+ *
+ * Prefer `links` for relationships to other entities.
+ */
+export interface Property {
+    id: string;
+    name: string;
+    schema: Schema;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    /**
+     * Marks this property as the primary identifier for the object type.
+     *
+     * A primary property uniquely identifies an object instance within its type
+     * (e.g., `externalId`). At most one property per object type may be primary.
+     *
+     * Only `true` is accepted — there is no "explicitly not primary" concept.
+     * Validation and runtime enforcement are handled separately.
+     */
+    primary?: true;
+    /**
+     * Runtime behavior of this property's value.
+     *
+     * - `"static"` (default) — a fact that rarely changes, stored as part of the object record.
+     * - `"telemetry"` — a time-varying measurement; each value is appended to a time-series
+     *   store and the object record holds only the latest value.
+     *
+     * @default "static"
+     */
+    mode?: PropertyMode;
+    /**
+     * Physical quantity this property measures.
+     *
+     * Constrains which units are valid for this property's values.
+     * Only meaningful when `schema` is a numeric type (`"double"`, `"integer"`, `"decimal"`).
+     *
+     * @example `semanticType: "Temperature"` — allows `degreeCelsius`, `degreeFahrenheit`, `kelvin`
+     * @example `semanticType: "Pressure"` — allows `bar`, `pascal`, `millibar`, etc.
+     */
+    semanticType?: QuantitativeTypeId;
+    /** Query/indexing metadata for this property. */
+    query?: PropertyQueryMetadata;
+}
+/**
+ * How a property's value behaves at runtime.
+ *
+ * - `"static"` — a fact that rarely changes (serial number, manufacturer).
+ *    Stored as part of the object record.
+ * - `"telemetry"` — a time-varying measurement or sensor reading.
+ *    Each new value is appended to a time-series store and the object
+ *    record holds only the latest value.
+ *
+ * When omitted, the property is treated as static.
+ */
+export type PropertyMode = "static" | "telemetry";
+export type LinkCardinality = "one" | "many";
+/**
+ * Relationship from one object type to another object type.
+ *
+ * Use links for graph edges in the ontology.
+ *
+ * Example:
+ * - `Building --contains--> Room` with `cardinality: "many"`
+ * - `Room --hasPrimaryThermostat--> Thermostat` with `cardinality: "one"`
+ *
+ * Relationship instances can also carry metadata via `properties`, such as
+ * `installedAt`, `commissionedBy`, or `confidenceScore`.
+ */
+export interface ObjectLink {
+    id: string;
+    name: string;
+    description?: string;
+    targetObjectTypeId: string | string[];
+    /** Cardinality from this source object to the target object type. */
+    cardinality?: LinkCardinality;
+    /** Optional metadata attached to each relationship instance. */
+    properties?: Property[];
+}
+declare const objectLinkTargetTypeBrand: unique symbol;
+/**
+ * Type-only metadata attached by `link("id", Target)`.
+ *
+ * The runtime ontology still stores only `targetObjectTypeId`; this brand exists
+ * only in TypeScript so query builders can resolve direct link targets without
+ * consulting a generated id-to-type map.
+ */
+export type ObjectLinkTargetMetadata<TTarget> = {
+    readonly [objectLinkTargetTypeBrand]?: TTarget;
+};
+export type ObjectLinkTargetType<TLink> = typeof objectLinkTargetTypeBrand extends keyof TLink ? TLink extends ObjectLinkTargetMetadata<infer TTarget> ? TTarget : never : never;
+/**
+ * Reusable ontology contract of properties and links.
+ *
+ * Define shared semantics once, then implement in multiple object types.
+ *
+ * Example:
+ * - `Sensor` interface defines `manufacturer`, `model`, and link `locatedIn -> Space`.
+ * - `TemperatureSensor` and `CO2Sensor` object types both implement `Sensor`.
+ */
+export interface Interface {
+    id: string;
+    name: string;
+    description?: string;
+    properties: Property[];
+    links: ObjectLink[];
+}
+/**
+ * Canonical ontology node for a real-world asset, system, concept, or process.
+ *
+ * `ObjectType` is the primary modeling unit in Sixb ontology design.
+ * It combines:
+ * - `properties` for intrinsic attributes,
+ * - `links` for relationships,
+ * - and optional `implements` references for shared contracts.
+ *
+ * Example object types:
+ * - `Thermostat`
+ * - `HVACZone`
+ * - `AirHandlingUnit`
+ */
+export interface ObjectType {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Physical quantity this object type measures.
+     * Used for sensor/point types (e.g., Temperature_Sensor measures "Temperature").
+     */
+    quantityKind?: QuantitativeTypeId;
+    /** External documentation or reference URLs. */
+    seeAlso?: string[];
+    /** Parent object type id. Properties and links are inherited from the parent chain. */
+    extends?: string;
+    /**
+     * All parent type ids (includes extends).
+     *
+     * Used for multi-parent classification.
+     * The primary structural parent (property merge) is stored in `extends`.
+     * Additional parents are recorded here for subtype queries.
+     *
+     * Example: A Boiler is both an HVAC_Equipment (extends) and a Water_Heater (additional parent).
+     * `parents: ["acme:Document", "acme:HRDocument"]`
+     */
+    parents?: string[];
+    /**
+     * Interface implementation by id.
+     *
+     * Example:
+     * `implements: ["sensor", "commissionable"]`
+     */
+    implements?: string[];
+    properties: Property[];
+    links: ObjectLink[];
+    /** Search profile for this object type. */
+    search?: ObjectTypeSearchMetadata;
+}
+/**
+ * Ambient id-to-object-type index for app ontology definitions.
+ *
+ * Sixb generates a `.sixb/types/ontology.d.ts` module augmentation that adds
+ * entries here, letting client-side query types resolve string link targets
+ * like `"Customer"` to the exported `Customer` object type without changing the
+ * runtime ontology shape.
+ */
+export interface SixbObjectTypeMap {
+}
+/**
+ * Root ontology document for object type modeling.
+ *
+ * Use this as the top-level container when you want to version and ship
+ * a complete ontology definition.
+ */
+export interface Ontology {
+    id: string;
+    version: string;
+    objectTypes: ObjectType[];
+    valueTypes: ValueType[];
+    interfaces: Interface[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,74 @@
+/**
+ * Sixb Quantitative Types — public API.
+ *
+ * Two concepts:
+ * - **QuantitativeType** — a physical quantity with its valid units.
+ * - **Unit** — a specific unit of measurement.
+ *
+ * ```ts
+ * import { quantitativeTypes, getUnit, isValidUnit } from "@sixb/core"
+ *
+ * // Browse what's available
+ * quantitativeTypes.Temperature.units.degreeCelsius.symbol // "°C"
+ *
+ * // Validate a unit against a quantity
+ * isValidUnit("Temperature", "degreeCelsius") // true
+ * isValidUnit("Temperature", "millibar")      // false
+ * ```
+ */
+export type { QuantitativeType, Unit } from "./types";
+export type { QuantitativeTypeId, UnitId, UnitsOf } from "./quantitative-types";
+export { quantitativeTypes } from "./quantitative-types";
+import type { QuantitativeTypeId, UnitId } from "./quantitative-types";
+import type { Unit } from "./types";
+/**
+ * Look up a unit by its id.
+ *
+ * @example
+ * ```ts
+ * const u = getUnit("degreeCelsius")
+ * // => { name: "Degree Celsius", symbol: "°C", quantitativeTypeId: "Temperature" }
+ * ```
+ */
+export declare function getUnit(unitId: string): (Unit & {
+    quantitativeTypeId: string;
+}) | undefined;
+/**
+ * Get the record of valid units for a quantitative type.
+ *
+ * @example
+ * ```ts
+ * const units = getUnitsFor("Temperature")
+ * // => { degreeCelsius: { … }, degreeFahrenheit: { … }, kelvin: { … } }
+ * ```
+ */
+export declare function getUnitsFor(quantitativeTypeId: string): Record<string, Unit> | undefined;
+/**
+ * Check whether a unit id is valid for a given quantitative type.
+ *
+ * @example
+ * ```ts
+ * isValidUnit("Temperature", "degreeCelsius") // true
+ * isValidUnit("Temperature", "millibar")      // false
+ * ```
+ */
+export declare function isValidUnit(quantitativeTypeId: string, unitId: string): boolean;
+/**
+ * Get the display symbol for a unit id.
+ *
+ * @example
+ * ```ts
+ * getUnitSymbol("degreeCelsius") // "°C"
+ * getUnitSymbol("unknown")       // undefined
+ * ```
+ */
+export declare function getUnitSymbol(unitId: string): string | undefined;
+/**
+ * Type guard: checks if a string is a valid `QuantitativeTypeId`.
+ */
+export declare function isQuantitativeTypeId(value: string): value is QuantitativeTypeId;
+/**
+ * Type guard: checks if a string is a valid `UnitId`.
+ */
+export declare function isUnitId(value: string): value is UnitId;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ontology/units/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,YAAY,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAIrD,YAAY,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAIxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAEtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAgBnC;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,GAAG;IAAE,kBAAkB,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CAE3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,SAAS,CAGxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAG/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEhE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,kBAAkB,CAE/E;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CAEvD"}