@sixb/core 0.1.9 → 0.1.10

package/src/storage/ontology/in-memory/sources.ts

@@ -13,6 +13,7 @@ import {
   isExactStagingManifest,
   sourceConflict,
   sourceMaterializationIdentity,
+  sourceStageRoots,
 } from "../provider"
 import type {
   AbandonSourceMaterializationCandidateInput,
@@ -32,6 +33,7 @@ import type {
   SummarizeTerminalSourceMaterializationsInput,
   TerminalSourceMaterializationSummary,
 } from "../sources"
+import { findActiveSourceMaterialization } from "./materializations-state"
 import {
   assertNonblank,
   type InMemoryOntologyState,
@@ -93,6 +95,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         projectionRevision: input.projectionRevision,
         ownershipHash: input.ownershipHash,
         ontologyRevision: input.ontologyRevision,
+        ...(input.base ? { base: structuredClone(input.base) } : {}),
         rootCount: null,
         assertionCount: null,
         createdAt: input.createdAt,
@@ -102,6 +105,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         lastCommitId: null,
         updatedAt: input.createdAt,
         rowsByEntity: new Map(),
+        roots: new Map(),
         rootOrdinals: new Map(),
         ordinalRoots: new Map(),
       }
@@ -121,7 +125,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
           `Source materialization '${input.materializationId}' is '${materialization.status}' and cannot accept rows.`
         )
       }
-      return stageRowsAtomically(materialization, input.rows)
+      return stageRowsAtomically(materialization, input)
     })
   }
 
@@ -178,18 +182,12 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
   async getActive(input: GetActiveOntologySourceInput): Promise<OntologySourceRecord | null> {
     return this.runRootOperation(() => {
       assertProjectAndSource(input)
-      const active = [...this.state.sourceMaterializations.values()].filter(
-        (materialization) =>
-          materialization.projectId === input.projectId &&
-          materialization.source.projectionId === input.source.projectionId &&
-          materialization.status === "active"
+      const active = findActiveSourceMaterialization(
+        this.state,
+        input.projectId,
+        input.source.projectionId
       )
-      if (active.length > 1) {
-        throw sourceConflict(
-          `Source '${input.source.projectionId}' has more than one active materialization.`
-        )
-      }
-      return active[0] ? sourceMaterializationRecord(active[0]) : null
+      return active ? sourceMaterializationRecord(active) : null
     })
   }
 
@@ -230,6 +228,14 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         ) {
           continue
         }
+        if (
+          materialization.roots.size > 0 &&
+          ![...materialization.roots.values()].some(
+            (root) =>
+              !root.active && root.retiredAt !== null && root.retiredAt < input.terminalBefore
+          )
+        )
+          continue
         insertBounded(candidates, entry, input.limit, compareTerminalMaterializations)
       }
 
@@ -240,18 +246,28 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         if (remaining === 0) break
         const current = this.state.sourceMaterializations.get(key)
         if (current !== candidate) continue
-        // Terminal manifests never participate in reads or activation again. Release their
-        // ingestion-only indexes immediately instead of retaining O(root count) memory until the
-        // last child row is removed by a later bounded cleanup pass.
         current.rootOrdinals.clear()
         current.ordinalRoots.clear()
-        for (const entityKey of current.rowsByEntity.keys()) {
+        for (const [rootKey, root] of current.roots) {
           if (remaining === 0) break
-          current.rowsByEntity.delete(entityKey)
-          rowsDeleted += 1
-          remaining -= 1
+          if (root.active || root.retiredAt === null || root.retiredAt >= input.terminalBefore)
+            continue
+          for (const entityKey of root.entityKeys) {
+            if (remaining === 0) break
+            current.rowsByEntity.delete(entityKey)
+            root.entityKeys.delete(entityKey)
+            rowsDeleted += 1
+            remaining -= 1
+          }
+          if (root.entityKeys.size === 0 && remaining > 0) {
+            current.roots.delete(rootKey)
+            current.rootOrdinals.delete(rootKey)
+            current.ordinalRoots.delete(root.stagingOrdinal)
+            rowsDeleted += 1
+            remaining -= 1
+          }
         }
-        if (current.rowsByEntity.size === 0 && remaining > 0) {
+        if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
           this.state.sourceMaterializations.delete(key)
           materializationsDeleted += 1
           remaining -= 1
@@ -372,6 +388,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
     if (materialization.readyAt !== null) {
       assertNotBefore(abandonedAt, materialization.readyAt, "Source abandonedAt", "readyAt")
     }
+    for (const root of materialization.roots.values()) root.retiredAt = abandonedAt
     const abandoned: InMemorySourceMaterialization = {
       ...materialization,
       status: "abandoned",
@@ -407,14 +424,33 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
 
 function stageRowsAtomically(
   materialization: InMemorySourceMaterialization,
-  rows: StageSourceRowsInput["rows"]
+  input: StageSourceRowsInput
 ): StageSourceRowsResult {
   let inserted = 0
   let unchanged = 0
   const newRows = new Map<string, StageSourceRowsInput["rows"][number]>()
   const newRootOrdinals = new Map<string, number>()
   const newOrdinalRoots = new Map<number, string>()
-  for (const row of rows) {
+  const roots = sourceStageRoots(materialization.projectionKind, input)
+  if (!materialization.base && roots.some((root) => root.deleted)) {
+    throw new MaterializationValidationError("Root deletions require a source delta base.")
+  }
+  for (const root of roots) {
+    const previous = materialization.roots.get(root.rootKey)
+    const otherRoot = materialization.ordinalRoots.get(root.stagingOrdinal)
+    if (
+      (previous &&
+        (previous.deleted !== root.deleted || previous.stagingOrdinal !== root.stagingOrdinal)) ||
+      (otherRoot !== undefined && otherRoot !== root.rootKey)
+    ) {
+      throw new MaterializationValidationError(
+        "Source materialization repeats root or stream ordinal with different content."
+      )
+    }
+    newRootOrdinals.set(root.rootKey, root.stagingOrdinal)
+    newOrdinalRoots.set(root.stagingOrdinal, root.rootKey)
+  }
+  for (const row of input.rows) {
     assertSourceStagedRow(materialization.projectionKind, row)
 
     const rootKey = projectionEntityKey(row.root)
@@ -458,7 +494,21 @@ function stageRowsAtomically(
   for (const [ordinal, rootKey] of newOrdinalRoots) {
     materialization.ordinalRoots.set(ordinal, rootKey)
   }
-  for (const [entityKey, row] of newRows) materialization.rowsByEntity.set(entityKey, row)
+  for (const root of roots) {
+    if (!materialization.roots.has(root.rootKey))
+      materialization.roots.set(root.rootKey, {
+        root: structuredClone(root.root),
+        stagingOrdinal: root.stagingOrdinal,
+        deleted: root.deleted,
+        entityKeys: new Set(),
+        active: false,
+        retiredAt: null,
+      })
+  }
+  for (const [entityKey, row] of newRows) {
+    materialization.rowsByEntity.set(entityKey, row)
+    materialization.roots.get(projectionEntityKey(row.root))!.entityKeys.add(entityKey)
+  }
   return { inserted, unchanged }
 }
 
@@ -497,6 +547,11 @@ function assertReadyTopology(materialization: InMemorySourceMaterialization): vo
 
   for (const rootKey of materialization.rootOrdinals.keys()) {
     const rows = rowsByRoot.get(rootKey) ?? []
+    if (materialization.roots.get(rootKey)?.deleted) {
+      if (rows.length > 0)
+        throw new MaterializationValidationError("Deleted source roots cannot contain assertions.")
+      continue
+    }
     const first = rows[0]
     if (!first) {
       throw new MaterializationValidationError(`Source root ${rootKey} has no staged assertions.`)

package/src/storage/ontology/index.ts

@@ -109,6 +109,7 @@ export type {
   OntologySourceStorage,
   ReclaimSourceMaterializationInput,
   StageSourceAssertion,
+  StageSourceRoot,
   StageSourceRowsInput,
   StageSourceRowsResult,
   StoredSourceAssertion,

package/src/storage/ontology/provider.ts

@@ -164,6 +164,7 @@ function isJsonValue(value: unknown): value is import("../../json").JsonValue {
 }
 
 export interface ProviderReplacementSessionState {
+  readonly incremental?: boolean
   readonly sourceId: string
   readonly candidateMaterializationId: string
   readonly previousMaterializationId: string | null
@@ -654,6 +655,66 @@ export function sourceStageRow(row: StageSourceAssertion): SourceStageRow {
   }
 }
 
+export interface SourceStageRoot {
+  readonly root: StageSourceAssertion["root"]
+  readonly rootKey: string
+  readonly sortKey: string
+  readonly stagingOrdinal: number
+  readonly deleted: boolean
+}
+
+/** Shared root identity rules, including deletions that deliberately have no assertion rows. */
+export function sourceStageRoots(
+  projectionKind: OntologySourceRecord["projectionKind"],
+  input: {
+    readonly rows: readonly StageSourceAssertion[]
+    readonly deletions?: readonly {
+      readonly root: StageSourceAssertion["root"]
+      readonly stagingOrdinal: number
+    }[]
+  }
+): readonly SourceStageRoot[] {
+  for (const row of input.rows) assertSourceStagedRow(projectionKind, row)
+  const roots = new Map<string, SourceStageRoot>()
+  const ordinals = new Map<number, string>()
+  for (const [items, deleted] of [
+    [input.rows, false],
+    [input.deletions ?? [], true],
+  ] as const) {
+    for (const row of items) {
+      assertSourceEntity(row.root, "Source root")
+      if (
+        row.root.kind !== projectionKind ||
+        !Number.isSafeInteger(row.stagingOrdinal) ||
+        row.stagingOrdinal < 0
+      ) {
+        throw new MaterializationValidationError("Source root kind or staging ordinal is invalid.")
+      }
+      const key = projectionEntityKey(row.root)
+      const previous = roots.get(key)
+      const otherRoot = ordinals.get(row.stagingOrdinal)
+      if (
+        (previous &&
+          (previous.deleted !== deleted || previous.stagingOrdinal !== row.stagingOrdinal)) ||
+        (otherRoot !== undefined && otherRoot !== key)
+      ) {
+        throw new MaterializationValidationError(
+          `Source materialization repeats root or stream ordinal ${row.stagingOrdinal} with different content.`
+        )
+      }
+      roots.set(key, {
+        root: row.root,
+        rootKey: key,
+        sortKey: utf8SortKey(key),
+        stagingOrdinal: row.stagingOrdinal,
+        deleted,
+      })
+      ordinals.set(row.stagingOrdinal, key)
+    }
+  }
+  return [...roots.values()]
+}
+
 export function reconcileSourceStageRows(
   rows: readonly SourceStageRow[],
   existingRows: readonly SourceStageRow[]
@@ -732,6 +793,13 @@ export function assertSourceBeginInput(input: BeginSourceMaterializationInput):
   assertNonblank(input.datasetVersion.versionId, "Source dataset version id")
   assertTimestamp(input.datasetVersion.createdAt, "Source dataset version createdAt", true)
   assertTimestamp(input.createdAt, "Source createdAt", true)
+  if (input.base) {
+    assertNonblank(input.base.materializationId, "Source base materialization id")
+    assertNonblank(input.base.lastCommitId, "Source base commit id")
+    if (input.base.materializationId === input.materializationId) {
+      throw new MaterializationValidationError("A source candidate cannot be its own base.")
+    }
+  }
 }
 
 export function assertSourceWriteIdentity(input: {
@@ -863,6 +931,8 @@ export function isExactStagingManifest(
     row.datasetVersion.createdAt === input.datasetVersion.createdAt &&
     row.projectionRevision === input.projectionRevision &&
     row.ownershipHash === input.ownershipHash &&
+    row.base?.materializationId === input.base?.materializationId &&
+    row.base?.lastCommitId === input.base?.lastCommitId &&
     row.ontologyRevision === input.ontologyRevision
   )
 }

package/src/storage/ontology/sources.ts

@@ -3,6 +3,7 @@ import type {
   ProjectionEntityRef,
   ProjectionExecution,
   ProjectionSourceAssertion,
+  ProjectionSourceBase,
   ProjectionSourceRef,
 } from "../../materialization/model"
 
@@ -32,7 +33,8 @@ export interface OntologySourceRecord {
   readonly projectionRevision: string
   readonly ownershipHash: string
   readonly ontologyRevision: string
-  /** Null until staging is sealed by markReady; zero explicitly represents an empty output. */
+  readonly base?: ProjectionSourceBase
+  /** Staged roots, including explicit deletions for a delta; null until sealed by markReady. */
   readonly rootCount: number | null
   /** Null until staging is sealed by markReady; zero explicitly represents an empty output. */
   readonly assertionCount: number | null
@@ -78,6 +80,7 @@ export interface BeginSourceMaterializationInput {
   readonly projectionRevision: string
   readonly ownershipHash: string
   readonly ontologyRevision: string
+  readonly base?: ProjectionSourceBase
   readonly createdAt: string
 }
 
@@ -94,6 +97,13 @@ export interface StageSourceRowsInput {
   readonly materializationId: string
   readonly execution: ProjectionExecution
   readonly rows: readonly StageSourceAssertion[]
+  /** Explicit root removals, allowed only for a candidate with a pinned base. */
+  readonly deletions?: readonly StageSourceRoot[]
+}
+
+export interface StageSourceRoot {
+  readonly root: ProjectionEntityRef
+  readonly stagingOrdinal: number
 }
 
 export interface StageSourceRowsResult {
@@ -139,13 +149,14 @@ export type AbandonSourceMaterializationInput =
 
 export interface CleanupTerminalSourceMaterializationsInput {
   readonly projectId: string
-  /** Exclusive cutoff applied only to superseded/abandoned terminalAt. */
+  /** Exclusive cutoff for retired roots in terminal manifests, and for empty terminal manifests. */
   readonly terminalBefore: string
-  /** Maximum total child-row plus manifest deletions performed by one call. */
+  /** Maximum total assertion, root-reference, and manifest deletions performed by one call. */
   readonly limit: number
 }
 
 export interface CleanupTerminalSourceMaterializationsResult {
+  /** Assertion rows and root references deleted. */
   readonly rowsDeleted: number
   readonly materializationsDeleted: number
 }

package/src/storage/projection-runs/lifecycle.ts

@@ -287,7 +287,7 @@ export function mergeProjectionRunProgress(
     const value = patch[key]
     if (value === undefined) continue
     assertProjectionRunCounter(value, key)
-    if (value < current[key]) {
+    if (value < (current[key] ?? 0)) {
       throw new ProjectionRunError(`[Sixb] Projection run ${key} must not decrease.`)
     }
     progress[key] = value
@@ -706,7 +706,10 @@ function projectionTargetsEqual(left: ProjectionTarget, right: ProjectionTarget)
 
 function assertProjectionRunProgress(progress: ProjectionRunProgress): void {
   for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
-    assertProjectionRunCounter(progress[key], key)
+    assertProjectionRunCounter(
+      key === "sourceChangesRead" ? (progress[key] ?? 0) : progress[key],
+      key
+    )
   }
   if (progress.sourceRowsSkipped > progress.sourceRowsRead) {
     throw new ProjectionRunError(

package/src/storage/projection-runs/types.ts

@@ -23,11 +23,14 @@ export interface ProjectionRunProgress {
   readonly sourceRowsRead: number
   /** Physical rows intentionally skipped because a required mapped value was blank. */
   readonly sourceRowsSkipped: number
+  /** Maximum complete change records consumed by one incremental attempt; not a recovery cursor. */
+  readonly sourceChangesRead?: number
 }
 
 const progressKeyFlags: Record<keyof ProjectionRunProgress, true> = {
   sourceRowsRead: true,
   sourceRowsSkipped: true,
+  sourceChangesRead: true,
 }
 
 export const PROJECTION_RUN_PROGRESS_KEYS = Object.keys(
@@ -35,9 +38,7 @@ export const PROJECTION_RUN_PROGRESS_KEYS = Object.keys(
 ) as readonly (keyof ProjectionRunProgress)[]
 
 export function zeroProjectionRunProgress(): ProjectionRunProgress {
-  const progress = {} as Record<keyof ProjectionRunProgress, number>
-  for (const key of PROJECTION_RUN_PROGRESS_KEYS) progress[key] = 0
-  return progress
+  return { sourceRowsRead: 0, sourceRowsSkipped: 0 }
 }
 
 export interface ProjectionTelemetryCheckpoint {

package/src/syncs/run-dispatch.ts

@@ -93,7 +93,10 @@ export class SyncRunDispatcher implements SyncRunDispatchPort {
 /** Persist a Sync execution and queued run before publishing its queue job. */
 export async function dispatchSyncRun(input: DispatchSyncRunInput): Promise<SyncRunRequestResult> {
   const runId = createSyncRunId(input.runId)
-  const persisted = await persistSyncRun(input, runId)
+  let persisted = await persistSyncRun(input, runId)
+  if (!persisted.publish && input.validateExistingRun && persisted.run.status === "queued") {
+    persisted = await reuseSyncRun(input, persisted.run)
+  }
   if (!persisted.publish) return existingSyncRunResult(persisted.run)
   return publishSyncRun(input, persisted)
 }
@@ -151,6 +154,15 @@ async function reuseSyncRun(
 ): Promise<PersistedSyncRun> {
   assertExistingRunMatchesRequest(existing, input)
   await input.validateExistingRun?.(existing, input.storage)
+  if (input.validateExistingRun && existing.status === "queued") {
+    const execution = await input.storage.executions.getById({
+      projectId: input.projectId,
+      id: existing.executionId,
+    })
+    if (!execution)
+      throw new SyncRunError(`[Sixb] Execution '${existing.executionId}' was not found.`)
+    return { publish: true, run: existing, execution, queuedAt: existing.queuedAt, created: false }
+  }
   if (
     existing.status !== "failed" ||
     existing.error?.code !== "queue.enqueue_failed" ||
@@ -200,6 +212,9 @@ async function publishSyncRun(
         },
       ],
     })
+    if (!job || job.id !== persisted.run.id) {
+      throw new SyncRunError(`[Sixb] Queue did not acknowledge Sync run '${persisted.run.id}'.`)
+    }
     return {
       syncId: persisted.run.syncId,
       runId: persisted.run.id,
@@ -208,6 +223,9 @@ async function publishSyncRun(
       created: persisted.created,
     }
   } catch (error) {
+    // Automatic consumers retain the batch and retry. Keep uncertain delivery queued:
+    // a lost reply does not prove that the queue rejected the job.
+    if (input.validateExistingRun) throw error
     const failedAt = new Date()
     const failure = toEnqueueFailure(error, persisted.run, failedAt)
     const failed = await requireSyncRunStorage(input.storage).finish({

package/src/testing/broker-contract.ts

@@ -446,6 +446,101 @@ export function runBrokerContractSuite<TBroker extends Broker>(
     })
 
     describe("subscribe", () => {
+      // Removing awaited provider delivery makes the second callback enter before release.
+      test("awaits async handlers without blocking publishers or other subscribers", async () => {
+        await withBroker(async (broker) => {
+          await broker.ensureStream({ projectId: "project-a", stream: eventsStream })
+          let release!: () => void
+          const blocked = new Promise<void>((resolve) => {
+            release = resolve
+          })
+          const received: string[] = []
+          const observer: string[] = []
+          const unsubscribe = await broker.subscribe(
+            { projectId: "project-a", streamId: eventsStream.id },
+            async (records) => {
+              received.push(...records.map((record) => String(record.payload)))
+              await blocked
+            }
+          )
+          const observe = await broker.subscribe(
+            { projectId: "project-a", streamId: eventsStream.id },
+            (records) => {
+              observer.push(...records.map((record) => String(record.payload)))
+            }
+          )
+          const wait = (predicate: () => boolean) =>
+            waitUntil(predicate, {
+              timeoutMs: subscriptionDeliveryTimeoutMs,
+              intervalMs: subscriptionPollIntervalMs,
+              message: "Async broker subscription did not progress",
+            })
+          try {
+            if (subscriptionSetupMs > 0) await Bun.sleep(subscriptionSetupMs)
+            await broker.append({
+              projectId: "project-a",
+              streamId: eventsStream.id,
+              records: [{ payload: "one" }],
+            })
+            await wait(() => received.length === 1)
+            await broker.append({
+              projectId: "project-a",
+              streamId: eventsStream.id,
+              records: [{ payload: "two" }],
+            })
+            await wait(() => observer.length === 2)
+            await Bun.sleep(30)
+            expect(received).toEqual(["one"])
+            release()
+            await wait(() => received.length === 2)
+            expect(received).toEqual(["one", "two"])
+          } finally {
+            release()
+            unsubscribe()
+            observe()
+          }
+        })
+      })
+
+      test("isolates rejected async handlers and permits appending from a handler", async () => {
+        await withBroker(async (broker) => {
+          await broker.ensureStream({ projectId: "project-a", stream: eventsStream })
+          const received: string[] = []
+          const unsubscribe = await broker.subscribe(
+            { projectId: "project-a", streamId: eventsStream.id },
+            async (records) => {
+              for (const record of records) {
+                received.push(String(record.payload))
+                if (record.payload === "one") {
+                  await broker.append({
+                    projectId: "project-a",
+                    streamId: eventsStream.id,
+                    records: [{ payload: "two" }],
+                  })
+                  throw new Error("observer failure")
+                }
+              }
+            }
+          )
+          try {
+            if (subscriptionSetupMs > 0) await Bun.sleep(subscriptionSetupMs)
+            await broker.append({
+              projectId: "project-a",
+              streamId: eventsStream.id,
+              records: [{ payload: "one" }],
+            })
+            await waitUntil(() => received.length === 2, {
+              timeoutMs: subscriptionDeliveryTimeoutMs,
+              intervalMs: subscriptionPollIntervalMs,
+              message: "Rejected async observer blocked later delivery",
+            })
+            expect(received).toEqual(["one", "two"])
+          } finally {
+            unsubscribe()
+          }
+        })
+      })
+
       test("requires streams to be ensured before subscribing", async () => {
         await withBroker(async (broker) => {
           await expect(

package/src/testing/connector-connection-storage-contract.ts

@@ -90,6 +90,22 @@ export function runConnectorConnectionStorageContractSuite<
       })
     })
 
+    test("persists explicitly non-PKCE attempts without a verifier", async () => {
+      // Removal proof: restore required code_verifier storage or omit migration 038; SQL providers fail.
+      await withStorage(async (storage) => {
+        const { codeVerifier: _verifier, ...input } = authorizationAttempt()
+        const created = await storage.createAuthorizationAttempt(input)
+        expect(created).not.toHaveProperty("codeVerifier")
+        const consumed = await storage.consumeAuthorizationAttempt(
+          authorizationAttemptConsumption()
+        )
+        expect(consumed).not.toHaveProperty("codeVerifier")
+        await expect(
+          storage.consumeAuthorizationAttempt(authorizationAttemptConsumption())
+        ).rejects.toThrow("invalid, expired, or already used")
+      })
+    })
+
     test("expires authorization attempts from the authoritative storage clock", async () => {
       await withStorage(async (storage, root) => {
         const ttlMs = 60_000
@@ -110,12 +126,13 @@ export function runConnectorConnectionStorageContractSuite<
     test("returns detached authorization attempt records", async () => {
       await withStorage(async (storage) => {
         const created = await storage.createAuthorizationAttempt(authorizationAttempt())
+        if (!created.codeVerifier) throw new Error("Expected a stored PKCE verifier.")
         Object.assign(created.codeVerifier, { ciphertext: "mutated" })
 
         const consumed = await storage.consumeAuthorizationAttempt(
           authorizationAttemptConsumption()
         )
-        expect(consumed.codeVerifier.ciphertext).toBe(credentials.ciphertext)
+        expect(consumed.codeVerifier?.ciphertext).toBe(credentials.ciphertext)
       })
     })
 

package/src/testing/index.ts

@@ -59,6 +59,7 @@ export {
   type ExecutionStorageContractSuiteOptions,
   runExecutionStorageContractSuite,
 } from "./execution-storage-contract"
+export { runLakeChangesContractSuite } from "./lake-changes-contract"
 export {
   type LakeMergeStorageContractSuiteOptions,
   runLakeMergeStorageContractSuite,