@bjornpagen/bumbledb 1.0.1 → 1.2.0

package/src/result.ts

@@ -5,31 +5,22 @@ import { dbNative } from "#db-native.ts"
 import type { FindColumn } from "#query/atom.ts"
 import { decodeAnswers } from "#query/run.ts"
 import type { CellValue } from "#rows.ts"
-import type { ExecutionPolicy } from "#runtime.ts"
-import { deliveryResultBytes, nativeOperationWith, policyWire } from "#runtime.ts"
+import { nativeOperationWith } from "#runtime.ts"
 import type { CloseReport, DbError } from "#runtime-errors.ts"
 
 /**
- * `CompleteResult<A>` — the sealed owner of one completed query answer:
- * published only after all evaluation/finalization succeeded,
- * possibly backed by temporary LMDB scratch. Owned and independent of its
- * source snapshot/session.
+ * One complete answer set, sealed after evaluation and independent of its
+ * source snapshot. collect() explicitly materializes all rows into JS and
+ * leaves the result available. pages() consumes it once through bounded
+ * delivery batches; it does not stream query execution.
  *
- * `collect` materializes a bounded owned array and leaves the result
- * available; it refuses (`ResourceLimit`) before allocating past
- * `maxBytes`, and a cap failure leaves the sealed backing available for
- * `pages`. `pages` is a one-shot consuming stream over the
- * completed result: its first execution atomically spends the result and
- * moves the backing storage into a private cursor owned by the stream's
- * scope — construction alone spends nothing, a second run fails
- * `SpentHandle`, and a run after the result's scope closed fails
- * `ClosedHandle`. Early take, downstream failure and interruption all
- * close/drain the private cursor; EOF cleanup is identical. There is no
- * public cursor, `next`, AsyncIterable, clone or second streaming API.
+ * The stream owns its cursor through Effect scope. Early termination,
+ * failure, interruption and EOF close/drain it. Creating the stream does
+ * not spend the result; running it twice fails with SpentHandle.
  */
 interface CompleteResult<A> {
-	collect(options: { readonly maxBytes: bigint }, work: ExecutionPolicy): Effect.Effect<ReadonlyArray<A>, DbError>
-	pages(options: { readonly pageBytes: bigint }, work: ExecutionPolicy): Stream.Stream<ReadonlyArray<A>, DbError>
+	collect(): Effect.Effect<ReadonlyArray<A>, DbError>
+	pages(): Stream.Stream<ReadonlyArray<A>, DbError>
 	close(): Effect.Effect<CloseReport>
 }
 
@@ -52,42 +43,27 @@ function decodePage<A>(finds: readonly FindColumn[], rows: readonly (readonly Ce
 
 /**
  * Internal constructor: `db.ts` publishes results through this after
- * execution completes. Delivery (`collect`/`pages`) starts a fresh bounded
- * operation under the caller's delivery policy — never the completed query's
- * expired execution deadline.
+ * execution completes. Each delivery has independent cooperative cancellation.
  */
 function makeCompleteResult<A>(handle: ResultHandle, finds: readonly FindColumn[]): CompleteResult<A> {
-	function deliveryWire(operation: string, delivery: ExecutionPolicy, requested: bigint) {
-		return policyWire({ ...delivery, resultBytes: deliveryResultBytes(requested, delivery) }, operation)
-	}
 	const value: CompleteResult<A> = {
-		collect(options, work) {
+		collect() {
 			return Effect.suspend(() =>
 				nativeOperationWith(
 					"CompleteResult.collect",
-					(callback) =>
-						dbNative.runtimeResultCollect(
-							handle,
-							deliveryWire("CompleteResult.collect", work, options.maxBytes),
-							callback
-						),
+					(callback) => dbNative.runtimeResultCollect(handle, callback),
 					dbNative.runtimeRowsTake,
 					(rows) => decodePage<A>(finds, rows)
 				)
 			)
 		},
-		pages(options, work) {
+		pages() {
 			return Stream.unwrap(
 				Effect.gen(function* () {
 					const cursor: CursorHandle = yield* Effect.acquireRelease(
 						nativeOperationWith(
 							"CompleteResult.pages",
-							(callback) =>
-								dbNative.runtimeResultCursor(
-									handle,
-									deliveryWire("CompleteResult.pages", work, options.pageBytes),
-									callback
-								),
+							(callback) => dbNative.runtimeResultCursor(handle, callback),
 							dbNative.runtimeCursorTake,
 							(taken) => taken
 						),
@@ -97,12 +73,7 @@ function makeCompleteResult<A>(handle: ResultHandle, finds: readonly FindColumn[
 					return Stream.paginate(undefined, () =>
 						nativeOperationWith(
 							"CompleteResult.page",
-							(callback) =>
-								dbNative.runtimeCursorNext(
-									cursor,
-									deliveryWire("CompleteResult.page", work, options.pageBytes),
-									callback
-								),
+							(callback) => dbNative.runtimeCursorNext(cursor, callback),
 							dbNative.runtimePageTake,
 							(page) => page
 						).pipe(

package/src/rows.ts

@@ -17,12 +17,9 @@ import { AuthoringError, SdkInvariantError } from "#errors.ts"
  * scans and byte copies.
  */
 import type { AnyClosedRoster, AnyField } from "#fields.ts"
-import { isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
-import type { AnyRelation, Fact, RelationData } from "#relation.ts"
-import { Uuid } from "#uuid.ts"
-
-/** Converter-granularity host cell wall (64 KiB). One oversize cell refuses. */
-const HOST_CELL_MAX = 65536n
+import { literalShapeError, rosterOf } from "#fields.ts"
+import { type AnyRelation, type Fact, relationFields } from "#relation.ts"
+import { fieldValue, recordValue } from "#values.ts"
 
 /**
  * One owned cell at the private bridge boundary. The declared sealed field
@@ -44,29 +41,18 @@ type CellValue =
 interface FlatRows {
 	readonly rows: bigint
 	readonly cells: readonly CellValue[]
-	/** Conservative charged byte size of the owned cells (input accounting). */
-	readonly bytes: bigint
 }
 
 function recordOf(fact: object): Readonly<Record<string, unknown>> {
-	if (typeof fact !== "object" && typeof fact !== "function") {
-		throw new AuthoringError({ message: "fact object is not string-indexable" })
+	if (typeof fact !== "object" || fact === null) {
+		throw new AuthoringError({ message: "expected a fact record" })
 	}
 	return fact as Readonly<Record<string, unknown>>
 }
 
-function refuseShared(context: string, value: Uint8Array): void {
-	if (!(value.buffer instanceof ArrayBuffer)) {
-		throw new AuthoringError({
-			message: `${context}: SharedArrayBuffer-backed views are refused — make a synchronized stable copy into ordinary unshared input first`
-		})
-	}
-}
-
 /**
- * Cheap host charge before any string scan or byte copy. Strings charge
- * two bytes per UTF-16 code unit, not their UTF-8 wire size. Native admission
- * measures and bounds UTF-8 separately; byte views charge their length.
+ * Approximate payload size for host batching, not a memory allowance.
+ * Strings use two bytes per UTF-16 code unit, not their UTF-8 wire size.
  */
 function hostCellCharge(value: unknown): bigint {
 	if (typeof value === "string") {
@@ -87,36 +73,11 @@ function hostCellCharge(value: unknown): bigint {
 	return 0n
 }
 
-function assertHostCellFits(context: string, value: unknown, limit: bigint): bigint {
-	const charge = hostCellCharge(value)
-	if (charge > limit) {
-		throw new AuthoringError({
-			message: `${context}: host cell of ${charge} bytes exceeds the ${limit}-byte converter bound — refuse before copy or scan`
-		})
-	}
-	return charge
-}
-
-/**
- * The write half of the closed bijection: one handle NAME to its u64 row
- * id (declaration order = row ids). An unknown name is a pointed refusal
- * naming the vocabulary and its roster.
- */
-function closedCellOf(context: string, closed: AnyClosedRoster, name: string): CellValue {
-	const id = closed.handles.indexOf(name)
-	if (id === -1) {
-		throw new AuthoringError({
-			message: `${context}: "${name}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`
-		})
-	}
-	return BigInt(id)
-}
-
 function handleOf(context: string, closed: AnyClosedRoster, cell: unknown): string {
 	if (typeof cell !== "bigint") {
 		throw literalShapeError(context, `a ${closed.name} handle id (bigint)`, cell)
 	}
-	const handle = closed.handles[Number(cell)]
+	const handle = cell < 0n || cell >= BigInt(closed.handles.length) ? undefined : closed.handles[Number(cell)]
 	if (handle === undefined) {
 		throw new AuthoringError({
 			message: `${context}: id ${cell} is outside the ${closed.name} roster (${closed.handles.join(", ")})`
@@ -125,227 +86,63 @@ function handleOf(context: string, closed: AnyClosedRoster, cell: unknown): stri
 	return handle
 }
 
-/** Conservative owned-byte charge of one cell (host accounting, not wire). */
-function cellBytes(cell: CellValue): bigint {
-	if (typeof cell === "boolean") {
-		return 1n
-	}
-	if (typeof cell === "bigint" || typeof cell === "number") {
-		return 8n
-	}
-	if (typeof cell === "string") {
-		// Account for the host string here; native admission separately
-		// checks and charges its exact UTF-8 encoding.
-		return BigInt(cell.length) * 2n
-	}
-	if (cell instanceof Uint8Array) {
-		return BigInt(cell.byteLength)
+function cellOf(context: string, field: AnyField, value: unknown): CellValue {
+	if ("closed" in field) {
+		return BigInt(field.closed.handles.indexOf(fieldValue(context, field, value)))
 	}
-	return 16n
+	return fieldValue(context, field, value)
 }
 
-function cellOf(context: string, field: AnyField, value: unknown): CellValue {
-	const roster = rosterOf(field)
-	if (roster !== undefined) {
-		if (typeof value !== "string") {
-			throw literalShapeError(context, `a ${roster.name} handle name (string)`, value)
-		}
-		return closedCellOf(context, roster, value)
-	}
-	switch (field.kind) {
-		case "bool": {
-			if (typeof value !== "boolean") {
-				throw literalShapeError(context, "boolean", value)
-			}
-			return value
-		}
-		case "u64":
-		case "i64": {
-			if (typeof value !== "bigint") {
-				throw literalShapeError(context, "bigint", value)
-			}
-			return value
-		}
-		case "str": {
-			if (typeof value !== "string") {
-				throw literalShapeError(context, "string", value)
-			}
-			assertHostCellFits(context, value, HOST_CELL_MAX)
-			if (!value.isWellFormed()) {
-				throw literalShapeError(context, "well-formed string", value)
-			}
-			return value
-		}
-		case "f64": {
-			if (typeof value !== "number") {
-				throw literalShapeError(context, "number", value)
-			}
-			return value
-		}
-		case "uuid": {
-			if (!Uuid.isUuid(value)) {
-				throw literalShapeError(context, "a UUID (canonical UUID text)", value)
-			}
-			// UUIDs cross as canonical hyphenated text, not raw bytes.
-			return value
-		}
-		case "bytes": {
-			if (!(value instanceof Uint8Array)) {
-				throw literalShapeError(context, "Uint8Array", value)
-			}
-			refuseShared(context, value)
-			assertHostCellFits(context, value, HOST_CELL_MAX)
-			if (value.byteLength !== field.width) {
-				throw new AuthoringError({
-					message: `${context}: bytes<${field.width}> takes exactly ${field.width} bytes (got ${value.byteLength})`
-				})
-			}
-			// Owned copy at the ownership boundary: later caller mutation
-			// cannot change an accepted cell.
-			return Uint8Array.from(value)
-		}
-		case "interval": {
-			if (field.element === "f64") {
-				if (!isFloatIntervalValue(value)) {
-					throw literalShapeError(context, "float interval ({ start, end } numbers)", value)
-				}
-				if (Number.isNaN(value.start) || Number.isNaN(value.end)) {
-					throw new AuthoringError({ message: `${context}: a float interval endpoint cannot be NaN` })
-				}
-				const start = Object.is(value.start, -0) ? 0 : value.start
-				const end = Object.is(value.end, -0) ? 0 : value.end
-				if (!(start < end)) {
-					throw new AuthoringError({
-						message: `${context}: a float interval is half-open and nonempty (start < end strictly)`
-					})
-				}
-				return { start, end }
-			}
-			if (!isIntervalValue(value)) {
-				throw literalShapeError(context, "interval ({ start, end } bigints)", value)
-			}
-			return { start: value.start, end: value.end }
-		}
-	}
+function factCellsOf(data: AnyRelation, fact: unknown): CellValue[] {
+	const record = recordValue(
+		`relation ${data.name}`,
+		fact,
+		relationFields(data).map((declared) => declared.name)
+	)
+	return relationFields(data).map((declared) =>
+		cellOf(`relation ${data.name} field ${declared.name}`, declared.field, record[declared.name])
+	)
 }
 
 /**
  * The flat projector: every fact's cells land in ONE row-major cell array
- * (length rows × arity) with the row count and charged byte size counted
- * while projecting. Missing-field refusal and per-cell judgment are
+ * (length rows × arity), counting rows while projecting.
+ * Missing-field refusal and per-cell judgment are
  * {@link cellOf}'s, byte for byte.
  */
-function flatRowsOf(data: RelationData, facts: Iterable<object>): FlatRows {
+function flatRowsOf(data: AnyRelation, facts: Iterable<object>): FlatRows {
 	const cells: CellValue[] = []
 	let rows = 0n
-	let bytes = 0n
 	for (const fact of facts) {
+		for (const cell of factCellsOf(data, fact)) cells.push(cell)
 		rows += 1n
-		const record = recordOf(fact)
-		for (const declared of data.fields) {
-			const value = record[declared.name]
-			if (value === undefined) {
-				throw new AuthoringError({ message: `relation ${data.name}: fact is missing field ${declared.name}` })
-			}
-			const cell = cellOf(`relation ${data.name} field ${declared.name}`, declared.field, value)
-			bytes += cellBytes(cell)
-			cells.push(cell)
-		}
 	}
-	return { rows, cells, bytes }
+	return { rows, cells }
 }
 
 function keyCellsOf(
-	data: RelationData,
+	data: AnyRelation,
 	projection: readonly string[],
-	key: Readonly<Record<string, unknown>>
+	input: Readonly<Record<string, unknown>>
 ): CellValue[] {
-	for (const supplied of Object.keys(key)) {
-		if (key[supplied] !== undefined && !projection.includes(supplied)) {
-			throw new AuthoringError({
-				message: `relation ${data.name}: key object carries field ${supplied} outside the primary key projection (${projection.join(", ")})`
-			})
-		}
-	}
+	const key = recordValue(`relation ${data.name} key`, input, projection)
 	return projection.map(function marshalKeyCell(fieldName) {
-		const declared = data.fields.find(function byName(candidate) {
-			return candidate.name === fieldName
-		})
+		const declared = relationFields(data).find((candidate) => candidate.name === fieldName)
 		if (declared === undefined) {
-			throw new AuthoringError({
-				message: `relation ${data.name}: key projection cites unknown field ${fieldName}`
-			})
+			throw new AuthoringError({ message: `relation ${data.name}: key projection cites unknown field ${fieldName}` })
 		}
-		const value = key[fieldName]
-		if (value === undefined) {
-			throw new AuthoringError({
-				message: `relation ${data.name}: key object is missing field ${fieldName} — get reads through the primary (first-declared) key, whose projection is (${projection.join(", ")})`
-			})
-		}
-		return cellOf(`relation ${data.name} key field ${fieldName}`, declared.field, value)
+		return cellOf(`relation ${data.name} key field ${fieldName}`, declared.field, key[fieldName])
 	})
 }
 
 function decodeCell(context: string, field: AnyField, cell: unknown): unknown {
 	const roster = rosterOf(field)
-	if (roster !== undefined) {
-		return handleOf(context, roster, cell)
-	}
-	switch (field.kind) {
-		case "bool": {
-			if (typeof cell !== "boolean") {
-				throw new SdkInvariantError({ message: `${context}: expected boolean cell` })
-			}
-			return cell
-		}
-		case "u64":
-		case "i64": {
-			if (typeof cell !== "bigint") {
-				throw new SdkInvariantError({ message: `${context}: expected bigint cell` })
-			}
-			return cell
-		}
-		case "f64": {
-			if (typeof cell !== "number") {
-				throw new SdkInvariantError({ message: `${context}: expected number cell` })
-			}
-			return cell
-		}
-		case "str": {
-			if (typeof cell !== "string") {
-				throw new SdkInvariantError({ message: `${context}: expected string cell` })
-			}
-			return cell
-		}
-		case "uuid": {
-			// The native renderer spells uuid as the canonical
-			// canonical hyphenated UUID string (marshal.rs `uuid_hex`); the read
-			// side revalidates the spelling and keeps the string value.
-			if (!Uuid.isUuid(cell)) {
-				throw new SdkInvariantError({
-					message: `${context}: expected an uuid cell (canonical UUID text)`
-				})
-			}
-			return cell
-		}
-		case "bytes": {
-			if (!(cell instanceof Uint8Array)) {
-				throw new SdkInvariantError({ message: `${context}: expected owned bytes` })
-			}
-			return cell
-		}
-		case "interval": {
-			if (field.element === "f64") {
-				if (!isFloatIntervalValue(cell)) {
-					throw new SdkInvariantError({ message: `${context}: expected a float interval cell` })
-				}
-				return Object.freeze({ start: cell.start, end: cell.end })
-			}
-			if (!isIntervalValue(cell)) {
-				throw new SdkInvariantError({ message: `${context}: expected an integer interval cell` })
-			}
-			return Object.freeze({ start: cell.start, end: cell.end })
-		}
+	if (roster !== undefined) return handleOf(context, roster, cell)
+	try {
+		return fieldValue(context, field, cell)
+	} catch (cause) {
+		if (cause instanceof AuthoringError) throw new SdkInvariantError({ message: cause.message })
+		throw cause
 	}
 }
 
@@ -353,7 +150,7 @@ function isCompleteFact<R extends AnyRelation>(
 	relation: R,
 	decoded: Readonly<Record<string, unknown>>
 ): decoded is Readonly<Record<string, unknown>> & Fact<R> {
-	return relation.data.fields.every(function present(declared) {
+	return relationFields(relation).every(function present(declared) {
 		return decoded[declared.name] !== undefined
 	})
 }
@@ -363,21 +160,22 @@ function isCompleteFact<R extends AnyRelation>(
  * declared field order: stable field names and shapes, no Proxy or per-cell closures.
  */
 function factOfCells<R extends AnyRelation>(relation: R, row: readonly unknown[]): Fact<R> {
-	const data = relation.data
-	if (row.length !== data.fields.length) {
+	const data = relation
+	if (row.length !== relationFields(data).length) {
 		throw new SdkInvariantError({
-			message: `relation ${data.name}: row arity ${row.length} does not match the ${data.fields.length} declared fields`
+			message: `relation ${data.name}: row arity ${row.length} does not match the ${relationFields(data).length} declared fields`
 		})
 	}
 	const decoded: Record<string, unknown> = {}
-	data.fields.forEach(function decodeOne(declared, ordinal) {
+	relationFields(data).forEach(function decodeOne(declared, ordinal) {
 		const cell = row[ordinal]
 		if (cell === undefined) {
 			throw new SdkInvariantError({
 				message: `relation ${data.name}: row cell ${ordinal} (${declared.name}) is absent`
 			})
 		}
-		decoded[declared.name] = decodeCell(`relation ${data.name} field ${declared.name}`, declared.field, cell)
+		const value = decodeCell(`relation ${data.name} field ${declared.name}`, declared.field, cell)
+		setOwnField(decoded, declared.name, value)
 	})
 	Object.freeze(decoded)
 	if (!isCompleteFact(relation, decoded)) {
@@ -386,16 +184,25 @@ function factOfCells<R extends AnyRelation>(relation: R, row: readonly unknown[]
 	return decoded
 }
 
+/** Preserve every declared name as data, including JavaScript's prototype setter. */
+function setOwnField(record: Record<string, unknown>, name: string, value: unknown): void {
+	if (name === "__proto__") {
+		Object.defineProperty(record, name, { value, enumerable: true, writable: true, configurable: true })
+	} else {
+		record[name] = value
+	}
+}
+
 export type { CellValue, FlatRows }
 export {
-	assertHostCellFits,
-	cellBytes,
 	cellOf,
 	decodeCell,
+	factCellsOf,
 	factOfCells,
 	flatRowsOf,
 	handleOf,
 	hostCellCharge,
 	keyCellsOf,
-	recordOf
+	recordOf,
+	setOwnField
 }

package/src/runtime-codes.ts

@@ -13,6 +13,5 @@ export const runtimeErrorCodes = [
 	"Io",
 	"ResourceLimit",
 	"Engine",
-	"Cancelled",
-	"DeadlineExceeded"
+	"Cancelled"
 ] as const

package/src/runtime-errors.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect"
+import { AuthoringDiagnostic, AuthoringError } from "#errors.ts"
 import { runtimeErrorCodes } from "#runtime-codes.ts"
 
 export { runtimeErrorCodes } from "#runtime-codes.ts"
@@ -12,7 +13,18 @@ const ResourceLimit = Schema.Struct({
 })
 const PlainReason = Schema.Struct({
 	_tag: Schema.Literals(
-		runtimeErrorCodes.filter((code) => code !== "ResourceLimit" && code !== "Io" && code !== "Engine")
+		runtimeErrorCodes.filter(
+			(code) => code !== "ResourceLimit" && code !== "Io" && code !== "Engine" && code !== "InvalidArgument"
+		)
+	)
+})
+const InvalidArgument = Schema.Struct({
+	_tag: Schema.Literal("InvalidArgument"),
+	detail: Schema.optional(
+		Schema.Struct({
+			message: Schema.String,
+			diagnostic: Schema.optional(AuthoringDiagnostic)
+		})
 	)
 })
 const Io = Schema.Struct({
@@ -26,7 +38,7 @@ const Engine = Schema.Struct({
 	kind: Schema.String,
 	message: Schema.String
 })
-export const DbReason = Schema.Union([ResourceLimit, Io, Engine, PlainReason])
+export const DbReason = Schema.Union([ResourceLimit, Io, Engine, InvalidArgument, PlainReason])
 export class DbError extends Schema.TaggedError<DbError>()("DbError", {
 	operation: Schema.String,
 	reason: DbReason
@@ -34,12 +46,44 @@ export class DbError extends Schema.TaggedError<DbError>()("DbError", {
 	get code() {
 		return this.reason._tag
 	}
+	/** Safe default display; callers explicitly inspect structured detail. */
+	override get message(): string {
+		return `${this.operation}: ${this.code}`
+	}
 }
 
 const decodeReason = Schema.decodeUnknownOption(DbReason)
 export function dbError(operation: string, cause: unknown): DbError {
+	if (cause instanceof DbError) return cause
+	if (cause instanceof AuthoringError) return argumentError(operation, cause)
 	const decoded = decodeReason(cause)
-	return new DbError({ operation, reason: decoded._tag === "Some" ? decoded.value : { _tag: "Internal" } })
+	if (decoded._tag === "Some") return new DbError({ operation, reason: decoded.value })
+	// Synchronous native schema/marshalling refusals precede the executor's
+	// tagged error wire. Preserve their engine family instead of losing it.
+	if (
+		typeof cause === "object" &&
+		cause !== null &&
+		"kind" in cause &&
+		typeof cause.kind === "string" &&
+		"message" in cause &&
+		typeof cause.message === "string"
+	) {
+		return new DbError({ operation, reason: { _tag: "Engine", kind: cause.kind, message: cause.message } })
+	}
+	return new DbError({ operation, reason: { _tag: "Internal" } })
+}
+
+/** Host input failures retain authoring details without displaying values. */
+export function argumentError(operation: string, cause: unknown): DbError {
+	if (cause instanceof DbError) return cause
+	if (cause instanceof AuthoringError) {
+		const detail =
+			cause.diagnostic === undefined
+				? { message: cause.message }
+				: { message: cause.message, diagnostic: cause.diagnostic }
+		return new DbError({ operation, reason: { _tag: "InvalidArgument", detail } })
+	}
+	return new DbError({ operation, reason: { _tag: "InvalidArgument" } })
 }
 
 const Outstanding = Schema.Struct({
@@ -49,11 +93,7 @@ const Outstanding = Schema.Struct({
 	retained: Schema.BigInt,
 	owners: Schema.BigInt,
 	databases: Schema.BigInt,
-	natives: Schema.BigInt,
-	inputBytes: Schema.BigInt,
-	workingBytes: Schema.BigInt,
-	scratchBytes: Schema.BigInt,
-	resultBytes: Schema.BigInt
+	natives: Schema.BigInt
 })
 export type OutstandingWork = typeof Outstanding.Type
 const Close = Schema.Union([