@eidos.space/eidos-file 3.6.0 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/FIELD-CONVERSION.md +6 -2
  2. package/dist/{adapter-contract-DLze8O3C.d.mts → adapter-contract-CSbe2Wbp.d.mts} +2 -2
  3. package/dist/{adapter-contract-DLze8O3C.d.mts.map → adapter-contract-CSbe2Wbp.d.mts.map} +1 -1
  4. package/dist/better-sqlite3.d.mts +2 -2
  5. package/dist/better-sqlite3.mjs +1 -1
  6. package/dist/browser.d.mts +4 -4
  7. package/dist/browser.d.mts.map +1 -1
  8. package/dist/browser.mjs +3 -3
  9. package/dist/browser.mjs.map +1 -1
  10. package/dist/{csv-NK8Rti5O.mjs → csv-DSZ72Fkf.mjs} +18 -6
  11. package/dist/csv-DSZ72Fkf.mjs.map +1 -0
  12. package/dist/csv.d.mts +5 -1
  13. package/dist/csv.d.mts.map +1 -1
  14. package/dist/csv.mjs +1 -1
  15. package/dist/index.d.mts +38 -5
  16. package/dist/index.d.mts.map +1 -1
  17. package/dist/index.mjs +400 -44
  18. package/dist/index.mjs.map +1 -1
  19. package/dist/node-sqlite.d.mts +9 -4
  20. package/dist/node-sqlite.d.mts.map +1 -1
  21. package/dist/node-sqlite.mjs +40 -3
  22. package/dist/node-sqlite.mjs.map +1 -1
  23. package/dist/{runtime-WzTMDrCe.d.mts → runtime-CB1g73FF.d.mts} +206 -14
  24. package/dist/runtime-CB1g73FF.d.mts.map +1 -0
  25. package/dist/{runtime-CTUCLd5Z.mjs → runtime-CpJ2VAXw.mjs} +1225 -178
  26. package/dist/runtime-CpJ2VAXw.mjs.map +1 -0
  27. package/dist/{sqlite-wasm-LbUUazaL.mjs → sqlite-wasm-Can22vNb.mjs} +8 -3
  28. package/dist/sqlite-wasm-Can22vNb.mjs.map +1 -0
  29. package/dist/{system-metadata-merge-D1jeYLZa.mjs → system-metadata-merge-BMBzxVo0.mjs} +123 -3
  30. package/dist/system-metadata-merge-BMBzxVo0.mjs.map +1 -0
  31. package/dist/{system-metadata-merge-CzWtCvqE.d.mts → system-metadata-merge-BNLOu74_.d.mts} +32 -3
  32. package/dist/{system-metadata-merge-CzWtCvqE.d.mts.map → system-metadata-merge-BNLOu74_.d.mts.map} +1 -1
  33. package/dist/{temporal-C-RGZNiQ.d.mts → temporal-DL3k3udh.d.mts} +6 -5
  34. package/dist/temporal-DL3k3udh.d.mts.map +1 -0
  35. package/package.json +4 -2
  36. package/dist/csv-NK8Rti5O.mjs.map +0 -1
  37. package/dist/runtime-CTUCLd5Z.mjs.map +0 -1
  38. package/dist/runtime-WzTMDrCe.d.mts.map +0 -1
  39. package/dist/sqlite-wasm-LbUUazaL.mjs.map +0 -1
  40. package/dist/system-metadata-merge-D1jeYLZa.mjs.map +0 -1
  41. package/dist/temporal-C-RGZNiQ.d.mts.map +0 -1
package/dist/index.mjs CHANGED
@@ -1,8 +1,8 @@
1
1
  import { A as isEidosFileUuid, C as assertEidosFileDisplayName, D as createEidosFileIdentifier, E as assertEidosFileUuid, F as EidosFileError, M as canonicalizeEidosFileJson, N as isCanonicalEidosFileJson, O as createEidosFileUuid, P as parseEidosFileJson, S as assertEidosFileColumnName, T as assertEidosFileTableName, _ as encodeEidosFileAttachmentPaths, a as parseEidosFileSelectOptions, b as normalizeEidosFileAttachmentPath, d as normalizeEidosFileDate, f as normalizeEidosFileInstant, g as eidosFileUriClass, h as decodeEidosFileValues, i as parseEidosFileSelectDefaultOption, j as quoteIdentifier, k as isEidosFileReservedTableName, l as isCanonicalEidosFileDate, m as decodeEidosFileAttachmentPaths, n as assertEidosFileSelectDefaultOption, o as currentEidosFileInstant, p as assertEidosFileValues, r as assertEidosFileSelectOptions, t as assertEidosFileMultiSelectHasNoDefaultOption, u as isCanonicalEidosFileInstant, v as encodeEidosFileValues, w as assertEidosFileTableId, x as EidosUuidV7Generator, y as isSafeEidosFileUri } from "./select-options-DSzDn3qm.mjs";
2
- import { a as eidosFileTypeHandler, c as AdapterTransportRuntimeClient, d as transportFitsHostLimit, f as validateAdapterCarrier, i as EidosFileSession, l as AdapterTransportServer, n as EidosFileHandlerRegistry, o as EidosFileRuntimeDataSource, p as validateAdapterEnvelope, r as EidosFileHostError, s as eidosFileSnapshot, t as SQLiteWasmConnectionPort, u as EIDOS_ADAPTER_TRANSPORT_LIMITS } from "./sqlite-wasm-LbUUazaL.mjs";
3
- import { $ as EIDOS_FILE_FORMAT, A as eidosFileLookupDisplayType, B as compileEidosFileFormula, C as isEidosFileFilterOperator, D as removeEidosFileFilterField, Dt as nativeToSqlValue, E as normalizeEidosFileSorts, F as eidosFileLookupValueType, G as configuredTypeRef, H as compileEidosFileFormulaSource, I as EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, J as eidosFileTypeRefQueryCapabilities, K as eidosFileFieldQueryCapabilities, L as EIDOS_FILE_FORMULA_FUNCTION_NAMES, M as eidosFileLookupStorageCodec, N as eidosFileLookupTargetDisplayType, O as eidosFileFieldStoresJsonArray, Ot as sqlValueToNative, P as eidosFileLookupTargetValueType, Q as EIDOS_FILE_FIELDS_TABLE, R as EIDOS_FILE_FORMULA_PROFILE, S as eidosFileSortExpression, St as EidosAdapterError, T as normalizeEidosFileRowQuery, Tt as assertUnicodeString, U as eidosFileFormulaReferences, V as compileEidosFileFormulaFields, W as rewriteEidosFileFormulaFieldReferences, X as EIDOS_FILE_EXTENSION, Y as EIDOS_FILE_APPLICATION_ID, Z as EIDOS_FILE_FEATURES_TABLE, _ as assertEidosFileRowQuery, _t as eidosFileTextMultiSelectChoices, a as EIDOS_FILE_FORMAT_VERSION_TEXT, at as EIDOS_FILE_RELATION_FIELDS_TABLE, b as eidosFileRowQueryPredicateColumns, bt as recommendedEidosFileConversionPolicies, c as incrementEidosFileRevision, ct as EIDOS_FILE_SYSTEM_COLUMNS, d as decodeEidosFileRelationDisplay, dt as SQLITE_HEADER, et as EIDOS_FILE_FORMAT_VERSION, f as decodeEidosFileRelationIds, ft as hasEidosFileSqliteHeader, g as parseNonNegativeInt64, gt as eidosFileConversionTargetNullable, h as cancellationPortFromSignal, ht as eidosFileConversionCanReusePhysicalColumn, i as scanStableRowPages, it as EIDOS_FILE_MIME_TYPE, j as eidosFileLookupElementType, k as eidosFileLookupAggregateSupportsTarget, l as initializeEidosFileSchema, lt as EIDOS_FILE_TABLES_TABLE, m as MemoryByteSource, mt as eidosFileColumnStatTypesForField, n as validateEidosFile, nt as EIDOS_FILE_LOOKUP_FIELDS_TABLE, o as EIDOS_FILE_SCHEMA_SQL, ot as EIDOS_FILE_REQUIRED_TABLES, p as encodeEidosFileRelationIds, pt as eidosFileColumnStatLabel, q as eidosFileFieldValueType, r as smallestDependencyCycle, rt as EIDOS_FILE_META_TABLE, s as configureEidosFileConnection, st as EIDOS_FILE_SCHEMA_VERSION, t as EidosFileRuntime, tt as EIDOS_FILE_FORMULA_FIELDS_TABLE, u as setEidosFileMetadata, ut as EIDOS_FILE_VIEWS_TABLE, v as compileEidosFileRowQuery, vt as isEidosFileUriReference, w as normalizeEidosFileFilter, wt as assertInt64Decimal, x as eidosFileRowQuerySearchFields, xt as ConnectionPortEidosFileConnection, y as eidosFileRowQueryAffectedByFieldChanges, yt as planCanonicalFieldConversion, z as assertEidosFileFormulaProfile } from "./runtime-CTUCLd5Z.mjs";
4
- import { _ as isMutableEidosFileFieldType, a as eidosFileCsvExportHeader, b as decodeEidosFileStringArray, c as importEidosFileCsv, d as prepareEidosFileCsvImport, f as MUTABLE_BASE_FIELD_TYPES, g as encodeEidosFileMultiSelectValues, h as eidosFileFieldDisplayValues, i as createEidosFileCsvRowEncoder, l as parseEidosFileCsvRows, m as eidosFileFieldConversionMayRequireLossyConfirmation, n as EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, o as eidosFileCsvRowToEidosFileRow, p as decodeEidosFileMultiSelectValues, r as createEidosFileCsvImportPlan, s as encodeEidosFileCsvRecord, t as EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, u as planEidosFileCsvImport, v as planEidosFileFieldConversion, x as encodeEidosFileJsonArray, y as decodeEidosFileJsonArray } from "./csv-NK8Rti5O.mjs";
5
- import { n as mergeEidosSystemMetadata, t as EIDOS_SYSTEM_METADATA_TABLES } from "./system-metadata-merge-D1jeYLZa.mjs";
2
+ import { a as eidosFileTypeHandler, c as AdapterTransportRuntimeClient, d as transportFitsHostLimit, f as validateAdapterCarrier, i as EidosFileSession, l as AdapterTransportServer, n as EidosFileHandlerRegistry, o as EidosFileRuntimeDataSource, p as validateAdapterEnvelope, r as EidosFileHostError, s as eidosFileSnapshot, t as SQLiteWasmConnectionPort, u as EIDOS_ADAPTER_TRANSPORT_LIMITS } from "./sqlite-wasm-Can22vNb.mjs";
3
+ import { $ as isEidosFileCalendarDayValue, $t as assertInt64Decimal, A as eidosFileRowQuerySearchFields, At as EIDOS_FILE_FORMULA_FIELDS_TABLE, B as isEidosFileCalendarWindowValue, Bt as SQLITE_HEADER, C as MemoryByteSource, Ct as eidosFileTypeRefQueryCapabilities, D as compileEidosFileRowQuery, Dt as EIDOS_FILE_FIELDS_TABLE, E as assertEidosFileRowQuery, Et as EIDOS_FILE_FEATURES_TABLE, F as normalizeEidosFileSorts, Ft as EIDOS_FILE_REQUIRED_TABLES, G as isEidosFileCalendarPeriodValue, Gt as eidosFileConversionTargetNullable, H as eidosFileCalendarPeriodBounds, Ht as eidosFileColumnStatLabel, I as removeEidosFileFilterField, It as EIDOS_FILE_SCHEMA_VERSION, J as EIDOS_FILE_CALENDAR_TIME_ZONE_DATA, Jt as planCanonicalFieldConversion, K as EIDOS_FILE_CALENDAR_MAX_YEAR, Kt as eidosFileTextMultiSelectChoices, L as EIDOS_FILE_CALENDAR_WINDOW_COUNT_MAX, Lt as EIDOS_FILE_SYSTEM_COLUMNS, M as isEidosFileFilterOperator, Mt as EIDOS_FILE_META_TABLE, N as normalizeEidosFileFilter, Nt as EIDOS_FILE_MIME_TYPE, O as eidosFileRowQueryAffectedByFieldChanges, Ot as EIDOS_FILE_FORMAT, P as normalizeEidosFileRowQuery, Pt as EIDOS_FILE_RELATION_FIELDS_TABLE, Q as eidosFileCalendarTimeZones, R as eidosFileCalendarWindowBounds, Rt as EIDOS_FILE_TABLES_TABLE, S as encodeEidosFileRelationIds, St as eidosFileFieldValueType, T as parseNonNegativeInt64, Tt as EIDOS_FILE_EXTENSION, U as hasEidosFileCalendarPeriodQuery, Ut as eidosFileColumnStatTypesForField, V as assertEidosFileCalendarContext, Vt as hasEidosFileSqliteHeader, W as hasEidosFileCalendarQuery, Wt as eidosFileConversionCanReusePhysicalColumn, X as eidosFileCalendarDateRangeIntervals, Xt as ConnectionPortEidosFileConnection, Y as assertEidosFileCalendarZone, Yt as recommendedEidosFileConversionPolicies, Z as eidosFileCalendarDayBounds, Zt as EidosAdapterError, _ as assertEidosFileTemporalDefault, _t as compileEidosFileFormulaSource, a as EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT_MAX_BYTES, at as eidosFileLookupDisplayType, b as decodeEidosFileRelationDisplay, bt as configuredTypeRef, c as upgradeEidosFileDateQuery, ct as eidosFileLookupTargetDisplayType, d as EIDOS_FILE_SCHEMA_SQL, dt as EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, en as assertUnicodeString, et as projectEidosFileCalendarInstant, f as configureEidosFileConnection, ft as EIDOS_FILE_FORMULA_FUNCTION_NAMES, g as assertEidosFileCreationContext, gt as compileEidosFileFormulaFields, h as setEidosFileMetadata, ht as compileEidosFileFormula, i as EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT, it as eidosFileLookupAggregateSupportsTarget, j as eidosFileSortExpression, jt as EIDOS_FILE_LOOKUP_FIELDS_TABLE, k as eidosFileRowQueryPredicateColumns, kt as EIDOS_FILE_FORMAT_VERSION, l as scanStableRowPages, lt as eidosFileLookupTargetValueType, m as initializeEidosFileSchema, mt as assertEidosFileFormulaProfile, n as validateEidosFile, nn as nativeToSqlValue, nt as supportsEidosFileCalendarProfile, o as eidosFileDateQueryUpgradeReceipt, ot as eidosFileLookupElementType, p as incrementEidosFileRevision, pt as EIDOS_FILE_FORMULA_PROFILE, q as EIDOS_FILE_CALENDAR_MIN_YEAR, qt as isEidosFileUriReference, r as smallestDependencyCycle, rn as sqlValueToNative, rt as eidosFileFieldStoresJsonArray, s as hasRetiredEidosFileDateQuery, st as eidosFileLookupStorageCodec, t as EidosFileRuntime, tt as resolveEidosFileCalendarInstant, u as EIDOS_FILE_FORMAT_VERSION_TEXT, ut as eidosFileLookupValueType, v as eidosFileTemporalDefaultValue, vt as eidosFileFormulaReferences, w as cancellationPortFromSignal, wt as EIDOS_FILE_APPLICATION_ID, x as decodeEidosFileRelationIds, xt as eidosFileFieldQueryCapabilities, y as enableTemporalDefaultsFeature, yt as rewriteEidosFileFormulaFieldReferences, z as hasEidosFileCalendarWindowQuery, zt as EIDOS_FILE_VIEWS_TABLE } from "./runtime-CpJ2VAXw.mjs";
4
+ import { _ as isMutableEidosFileFieldType, a as eidosFileCsvExportHeader, b as decodeEidosFileStringArray, c as importEidosFileCsv, d as prepareEidosFileCsvImport, f as MUTABLE_BASE_FIELD_TYPES, g as encodeEidosFileMultiSelectValues, h as eidosFileFieldDisplayValues, i as createEidosFileCsvRowEncoder, l as parseEidosFileCsvRows, m as eidosFileFieldConversionMayRequireLossyConfirmation, n as EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, o as eidosFileCsvRowToEidosFileRow, p as decodeEidosFileMultiSelectValues, r as createEidosFileCsvImportPlan, s as encodeEidosFileCsvRecord, t as EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, u as planEidosFileCsvImport, v as planEidosFileFieldConversion, x as encodeEidosFileJsonArray, y as decodeEidosFileJsonArray } from "./csv-DSZ72Fkf.mjs";
5
+ import { i as planEidosSchemaMerge, n as mergeEidosSystemMetadata, r as normalizeEidosSchemaMerge, t as EIDOS_SYSTEM_METADATA_TABLES } from "./system-metadata-merge-BMBzxVo0.mjs";
6
6
  //#region src/form-view.ts
7
7
  const EIDOS_FILE_FORM_VIEW_TYPE = "form";
8
8
  const EIDOS_FILE_FORM_INPUT_FIELD_TYPES = [
@@ -107,6 +107,12 @@ function mergeEidosFilePluginConfig(settings, pluginId, value, expectedVersion)
107
107
  };
108
108
  }
109
109
  //#endregion
110
+ //#region src/cli-host-initialization.ts
111
+ const initializers = /* @__PURE__ */ new WeakMap();
112
+ function registerCliTableInitializer(service, initialize) {
113
+ initializers.set(service, initialize);
114
+ }
115
+ //#endregion
110
116
  //#region src/runtime-service.ts
111
117
  const EIDOS_RUNTIME_LIMITS = Object.freeze({
112
118
  requestBytesMax: 8 * 1024 * 1024,
@@ -140,8 +146,14 @@ const EIDOS_RUNTIME_LIMITS = Object.freeze({
140
146
  undoBytesMax: 1
141
147
  });
142
148
  const READONLY_CAPABILITIES = Object.freeze({
149
+ viewCreationDefaultsVersion: 1,
150
+ calendarWindowVersion: 1,
151
+ temporalDefaultsVersion: 1,
152
+ calendarQueryVersion: 2,
153
+ calendarPeriodTimeZoneData: [EIDOS_FILE_CALENDAR_TIME_ZONE_DATA],
143
154
  readRows: true,
144
155
  batchRowPages: true,
156
+ rowIndex: true,
145
157
  schemaPaging: true,
146
158
  cursorPaging: true,
147
159
  aggregate: true,
@@ -224,6 +236,9 @@ var EidosRuntimeService = class {
224
236
  requestControls = /* @__PURE__ */ new Map();
225
237
  schemaPlans = /* @__PURE__ */ new Map();
226
238
  schemaPlanSequence = 0;
239
+ requestInstant;
240
+ requestCalendar;
241
+ requestedReference;
227
242
  queue = Promise.resolve();
228
243
  state = "open";
229
244
  constructor(connection, core, environment, writable, generator) {
@@ -233,11 +248,20 @@ var EidosRuntimeService = class {
233
248
  this.writable = writable;
234
249
  this.generator = generator;
235
250
  this.capabilitiesValue = runtimeCapabilities(writable);
251
+ registerCliTableInitializer(this, (change, context) => this.initializeCliTable(change, context));
236
252
  if (writable) this.importCsv = (request, context) => this.importCsvRequest(request, context);
237
253
  this.epoch = generator.next();
238
254
  this.cursorSecret = environment.entropy.randomBytes(16).slice();
239
255
  if (this.cursorSecret.byteLength !== 16) throw runtimeError("adapter-error", "EntropyPort returned an invalid cursor authentication key");
240
256
  this.hostBridge = {
257
+ queuedRead: (operation, context) => this.invoke(context, () => {
258
+ if (Object.prototype.toString.call(operation) === "[object AsyncFunction]") throw runtimeError("invalid-request", "Host read callbacks must complete synchronously");
259
+ return this.read(() => {
260
+ const value = operation();
261
+ if (value !== null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw runtimeError("invalid-request", "Host read callbacks must not return thenables");
262
+ return value;
263
+ });
264
+ }, false, void 0, false, false, true),
241
265
  allocateFileEntry: (request, context) => this.invoke(context, () => this.allocateFileEntry(request), false, request),
242
266
  createPublicationSnapshot: (request, context) => this.invoke(context, async () => {
243
267
  if (parseRevision(request.maxBytes, "maxBytes") < 0n) throw runtimeError("invalid-request", "maxBytes must be non-negative");
@@ -299,16 +323,18 @@ var EidosRuntimeService = class {
299
323
  }
300
324
  getSchemaPage(request, context) {
301
325
  return this.invoke(context, async () => this.read(async () => {
326
+ if (request.calendarWindowVersion !== void 0 && (request.calendarWindowVersion !== 1 || request.calendarQueryVersion !== 2)) throw runtimeError("unsupported", "Unsupported client calendar window version");
327
+ if (request.calendarQueryVersion !== void 0 && request.calendarQueryVersion !== 2) throw runtimeError("unsupported", "Unsupported client calendar query version");
302
328
  assertLimit(request.limit, EIDOS_RUNTIME_LIMITS.schemaPageSizeMax, "limit");
303
329
  const snapshot = this.snapshot();
304
330
  assertCurrentRevision(request.revision, snapshot.revision);
305
331
  let offset = 0;
306
332
  if (request.cursor !== void 0) {
307
333
  const payload = this.decodeCursor(request.cursor, "schema");
308
- if (payload.fileId !== snapshot.fileId || payload.revision !== request.revision || typeof payload.offset !== "number" || !Number.isSafeInteger(payload.offset) || payload.offset < 0) throw runtimeError("invalid-query", "Invalid schema cursor");
334
+ if (payload.fileId !== snapshot.fileId || payload.revision !== request.revision || payload.calendarQueryVersion !== (request.calendarQueryVersion ?? null) || payload.calendarWindowVersion !== (request.calendarWindowVersion ?? null) || typeof payload.offset !== "number" || !Number.isSafeInteger(payload.offset) || payload.offset < 0) throw runtimeError("invalid-query", "Invalid schema cursor");
309
335
  offset = payload.offset;
310
336
  }
311
- const objects = this.schemaDescriptors();
337
+ const objects = this.schemaDescriptors(request.calendarQueryVersion, request.calendarWindowVersion);
312
338
  const page = objects.slice(offset, offset + request.limit);
313
339
  if (offset > objects.length) throw runtimeError("invalid-query", "Schema cursor is past the end");
314
340
  const responseFor = (prefix) => {
@@ -320,6 +346,8 @@ var EidosRuntimeService = class {
320
346
  nextCursor: nextOffset < objects.length ? this.encodeCursor("schema", {
321
347
  fileId: snapshot.fileId,
322
348
  revision: snapshot.revision,
349
+ calendarQueryVersion: request.calendarQueryVersion ?? null,
350
+ calendarWindowVersion: request.calendarWindowVersion ?? null,
323
351
  offset: nextOffset
324
352
  }) : null
325
353
  };
@@ -342,7 +370,10 @@ var EidosRuntimeService = class {
342
370
  const direction = request.direction ?? "forward";
343
371
  const metadata = this.core.info();
344
372
  const projectionDigest = await projectionHash(request.projection);
345
- const queryDigest = await hashJson(normalizedRuntimeQuery(request.query));
373
+ const queryDigest = await hashJson({
374
+ query: normalizedRuntimeQuery(request.query),
375
+ calendar: this.requestCalendar ?? null
376
+ });
346
377
  const backwardQuery = reverseRuntimeQuery(request.query, this.core.listFields(request.tableId));
347
378
  const traversalQuery = direction === "forward" ? request.query : backwardQuery;
348
379
  const traversal = this.compatibilityQuery(request.tableId, traversalQuery);
@@ -354,10 +385,11 @@ var EidosRuntimeService = class {
354
385
  const selected = direction === "forward" ? cursor.forward : cursor.backward;
355
386
  if (typeof selected !== "string") throw runtimeError("invalid-query", "Row cursor boundary is invalid");
356
387
  coreCursor = selected;
388
+ if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
357
389
  }
358
390
  const extraFields = (request.query.sort ?? []).map((sort) => sort.fieldId);
359
391
  const fields = Array.from(new Set([...request.projection.fields, ...extraFields]));
360
- const result = this.core.queryRows(request.tableId, {
392
+ const resultRows = this.core.runtimeQueryRows(request.tableId, {
361
393
  fields,
362
394
  query: traversal,
363
395
  limit: request.limit + 1,
@@ -365,8 +397,8 @@ var EidosRuntimeService = class {
365
397
  cursor: coreCursor,
366
398
  resolveRelations: request.projection.resolveRelations.length > 0
367
399
  });
368
- const hasMoreInTraversal = result.rows.length > request.limit;
369
- const traversalRows = result.rows.slice(0, request.limit);
400
+ const hasMoreInTraversal = resultRows.length > request.limit;
401
+ const traversalRows = resultRows.slice(0, request.limit);
370
402
  const logicalRows = direction === "forward" ? traversalRows : traversalRows.reverse();
371
403
  const columns = this.columns(request.tableId, request.projection);
372
404
  const rows = this.projectRows(request.tableId, request.projection, logicalRows, columns);
@@ -377,6 +409,7 @@ var EidosRuntimeService = class {
377
409
  tableId: request.tableId,
378
410
  revision: String(metadata.revision),
379
411
  queryHash: queryDigest,
412
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
380
413
  projectionHash: projectionDigest,
381
414
  forward: this.core.createRowCursor(request.tableId, query, row),
382
415
  backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardQuery), row)
@@ -391,10 +424,14 @@ var EidosRuntimeService = class {
391
424
  projectionHash: projectionDigest,
392
425
  columns,
393
426
  rows,
427
+ ...usesClockFilter(request.query.filter) ? {
428
+ total: String(this.core.countRows(request.tableId, query)),
429
+ referenceInstant: this.requestInstant
430
+ } : {},
394
431
  nextCursor: hasLater ? boundaryCursor(logicalRows.at(-1)) : null,
395
432
  previousCursor: hasEarlier ? boundaryCursor(logicalRows[0]) : null
396
433
  };
397
- }), false, request);
434
+ }), false, request, true, true);
398
435
  }
399
436
  queryRowPages(request, context) {
400
437
  return this.invoke(context, async () => this.read(async () => {
@@ -414,7 +451,11 @@ var EidosRuntimeService = class {
414
451
  fileId: metadata.fileId,
415
452
  tableId: request.tableId,
416
453
  revision: String(metadata.revision),
417
- queryHash: await hashJson(normalizedRuntimeQuery(query)),
454
+ queryHash: await hashJson({
455
+ query: normalizedRuntimeQuery(query),
456
+ calendar: this.requestCalendar ?? null
457
+ }),
458
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
418
459
  projectionHash: projectionDigest,
419
460
  forward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, query), last),
420
461
  backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardQuery), last)
@@ -427,14 +468,18 @@ var EidosRuntimeService = class {
427
468
  columns,
428
469
  rows: this.projectRows(request.tableId, request.projection, page.rows, columns),
429
470
  total: String(page.total),
471
+ ...usesClockFilter(query.filter) ? { referenceInstant: this.requestInstant } : {},
430
472
  nextCursor,
431
473
  previousCursor: null
432
474
  };
433
475
  }));
434
- }), false, request);
476
+ }), false, request, true, true);
477
+ }
478
+ getRowIndex(request, context) {
479
+ return this.invoke(context, async () => this.read(async () => this.core.getRowIndexValue(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request, true, true);
435
480
  }
436
481
  getRecordNeighbors(request, context) {
437
- return this.invoke(context, async () => this.read(async () => this.core.getRecordNeighbors(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request);
482
+ return this.invoke(context, async () => this.read(async () => this.core.getRecordNeighbors(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request, true, true);
438
483
  }
439
484
  getRowsById(request, context) {
440
485
  return this.invoke(context, async () => this.read(async () => {
@@ -451,20 +496,22 @@ var EidosRuntimeService = class {
451
496
  }), false, request);
452
497
  }
453
498
  aggregate(request, context) {
454
- return this.invoke(context, () => this.read(() => this.aggregateNow(request)), false, request);
499
+ return this.invoke(context, () => this.read(() => this.aggregateNow(request)), false, request, true, true);
455
500
  }
456
501
  aggregateTable(tableId, options, query = {}) {
457
502
  return this.read(() => this.core.aggregateTable(tableId, options, query));
458
503
  }
459
504
  groupRows(request, context) {
460
- return this.invoke(context, async () => this.read(async () => this.groupRowsNow(request)), false, request);
505
+ return this.invoke(context, async () => this.read(async () => this.groupRowsNow(request)), false, request, true, true);
461
506
  }
462
507
  queryGroupRows(request, context) {
463
508
  return this.invoke(context, async () => this.read(async () => {
464
509
  assertLimit(request.limit, EIDOS_RUNTIME_LIMITS.pageSizeMax, "limit");
465
510
  const cursor = this.decodeCursor(request.cursor, "group-rows");
511
+ if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
466
512
  const source = cursor.request;
467
513
  if (!source || typeof source !== "object" || Array.isArray(source)) throw runtimeError("invalid-query", "Invalid group row cursor");
514
+ if (canonicalizeEidosFileJson(request.calendar ?? null) !== canonicalizeEidosFileJson(source.calendar ?? null)) throw runtimeError("invalid-query", "Group cursor calendar context mismatch");
468
515
  assertProjection(source.projection);
469
516
  const metadata = this.core.info();
470
517
  const projectionDigest = await projectionHash(source.projection);
@@ -497,6 +544,7 @@ var EidosRuntimeService = class {
497
544
  revision: String(metadata.revision),
498
545
  projectionHash: projectionDigest,
499
546
  bindingHash: bindingDigest,
547
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
500
548
  request: groupCursorSource(source),
501
549
  groupKey,
502
550
  forward: this.core.createRowCursor(source.tableId, this.compatibilityQuery(source.tableId, groupQuery), row),
@@ -512,11 +560,12 @@ var EidosRuntimeService = class {
512
560
  projectionHash: projectionDigest,
513
561
  columns,
514
562
  groupKey,
563
+ ...usesClockFilter(source.query.filter) ? { referenceInstant: this.requestInstant } : {},
515
564
  rows: this.projectRows(source.tableId, source.projection, logicalRows, columns),
516
565
  nextCursor: hasLater ? rowCursor(logicalRows.at(-1)) : null,
517
566
  previousCursor: hasEarlier ? rowCursor(logicalRows[0]) : null
518
567
  };
519
- }), false, request);
568
+ }), false, request, true, true);
520
569
  }
521
570
  previewFormula(request, context) {
522
571
  return this.invoke(context, () => {
@@ -584,6 +633,12 @@ var EidosRuntimeService = class {
584
633
  mutateRowsRequest(request, context, reversibleDeletes) {
585
634
  return this.invoke(context, async () => {
586
635
  this.assertWritable("mutateRows");
636
+ if (request.calendar !== void 0) {
637
+ assertEidosFileCalendarContext(request.calendar);
638
+ this.requestCalendar = request.calendar;
639
+ }
640
+ if (request.creationQuery !== void 0 && (!request.creationQuery || typeof request.creationQuery !== "object" || Array.isArray(request.creationQuery) || Object.keys(request.creationQuery).some((key) => key !== "filter"))) throw runtimeError("invalid-query", "Creation query accepts only a filter");
641
+ if (request.creationContext !== void 0) assertEidosFileCreationContext(request.creationContext);
587
642
  if (request.changes.length < 1 || request.changes.length > EIDOS_RUNTIME_LIMITS.mutationRowsMax) throw runtimeError("invalid-request", "changes must be within mutationRowsMax");
588
643
  if (request.changes.reduce((total, change) => total + ("values" in change ? Object.keys(change.values).length : 0), 0) > EIDOS_RUNTIME_LIMITS.mutationCellsMax) throw runtimeError("resource-limit", "Mutation exceeds mutationCellsMax");
589
644
  assertJcsBytes(request, EIDOS_RUNTIME_LIMITS.mutationBytesMax, "Row mutation");
@@ -622,7 +677,7 @@ var EidosRuntimeService = class {
622
677
  rowId
623
678
  });
624
679
  }
625
- const inserts = request.changes.filter((change) => change.kind === "create").map((change) => ({ fields: this.mutationValues(request.tableId, change.values, true) }));
680
+ const inserts = request.changes.filter((change) => change.kind === "create").map((change) => ({ fields: this.mutationValues(request.tableId, change.values, request.creationQuery?.filter === void 0, request.creationContext) }));
626
681
  const updates = request.changes.filter((change) => change.kind === "update").map((change) => ({
627
682
  id: change.rowId,
628
683
  fields: this.mutationValues(request.tableId, change.values)
@@ -636,6 +691,8 @@ var EidosRuntimeService = class {
636
691
  rows: []
637
692
  } : this.core.mutateRows({
638
693
  tableId: request.tableId,
694
+ ...request.creationQuery ? { creationQuery: this.compatibilityQuery(request.tableId, request.creationQuery) } : {},
695
+ creationContext: request.creationContext,
639
696
  insert: inserts,
640
697
  update: updates,
641
698
  delete: deletes,
@@ -710,7 +767,7 @@ var EidosRuntimeService = class {
710
767
  }));
711
768
  }, false, request);
712
769
  }
713
- mutationValues(tableId, values, completeCreate = false) {
770
+ mutationValues(tableId, values, completeCreate = false, creationContext) {
714
771
  const tableFields = this.core.listFields(tableId);
715
772
  const fields = new Map(tableFields.map((field) => [field.id, field]));
716
773
  const normalized = {};
@@ -738,6 +795,17 @@ var EidosRuntimeService = class {
738
795
  if (completeCreate) for (const field of tableFields) {
739
796
  const fieldId = field.id;
740
797
  if (!fieldWritable(field) || fieldId in normalized) continue;
798
+ if (field.type === "date" || field.type === "datetime") {
799
+ const value = eidosFileTemporalDefaultValue(field.type, field.settings, this.requestInstant ?? checkedNowInstant(this.environment), creationContext);
800
+ if (value !== null) {
801
+ normalized[fieldId] = value;
802
+ continue;
803
+ }
804
+ }
805
+ if (field.type === "checkbox") {
806
+ normalized[fieldId] = false;
807
+ continue;
808
+ }
741
809
  if (field.type === "select") {
742
810
  const defaultOption = parseEidosFileSelectDefaultOption(field.settings);
743
811
  if (defaultOption !== null) {
@@ -869,6 +937,8 @@ var EidosRuntimeService = class {
869
937
  async mutateView(request, context) {
870
938
  return this.invoke(context, () => {
871
939
  this.assertWritable("mutateView");
940
+ if (request.calendarWindowVersion !== void 0 && (request.calendarWindowVersion !== 1 || request.calendarQueryVersion !== 2)) throw runtimeError("invalid-request", "Unsupported calendar window consumer version");
941
+ if (request.calendarQueryVersion !== void 0 && request.calendarQueryVersion !== 2) throw runtimeError("invalid-request", "Unsupported calendar query consumer version");
872
942
  if (request.changes.length < 1) throw runtimeError("invalid-request", "View mutation changes are required");
873
943
  const before = this.core.info();
874
944
  assertCurrentRevision(request.expectedRevision, String(before.revision));
@@ -887,6 +957,7 @@ var EidosRuntimeService = class {
887
957
  this.core.applyCanonicalMutation(() => {
888
958
  for (const change of request.changes) {
889
959
  if (change.kind === "create-view") {
960
+ assertRuntimeSavedViewQuery(this.core.listFields(change.tableId), change.query);
890
961
  const view = this.core.createView(change.tableId, {
891
962
  name: assertEidosFileDisplayName(change.name, "View name"),
892
963
  type: change.type,
@@ -906,12 +977,33 @@ var EidosRuntimeService = class {
906
977
  affected.add(view.id);
907
978
  continue;
908
979
  }
909
- if (!this.allViews().find((view) => view.id === change.viewId)) throw runtimeError("not-found", "View not found");
980
+ const current = this.allViews().find((view) => view.id === change.viewId);
981
+ if (!current) throw runtimeError("not-found", "View not found");
910
982
  if (change.kind === "delete-view") {
911
983
  this.core.deleteView(change.viewId);
912
984
  affected.add(change.viewId);
913
985
  continue;
914
986
  }
987
+ if (change.kind === "upgrade-date-query" || change.kind === "restore-date-query") {
988
+ if (change.kind === "upgrade-date-query") {
989
+ const preview = upgradeEidosFileDateQuery(JSON.parse(current.query));
990
+ assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), preview.query);
991
+ } else {
992
+ const receipt = current.properties?.[EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT];
993
+ if (!receipt || typeof receipt !== "object" || Array.isArray(receipt) || !("originalQuery" in receipt)) throw runtimeError("invalid-value", "No date query recovery receipt is available");
994
+ const preview = upgradeEidosFileDateQuery(receipt.originalQuery);
995
+ assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), preview.query);
996
+ }
997
+ this.core.updateView(change.viewId, change.kind === "upgrade-date-query" ? { upgradeDateQuery: true } : { restoreDateQuery: true });
998
+ affected.add(change.viewId);
999
+ continue;
1000
+ }
1001
+ if (current.queryStatus === "unsupported" && change.patch.query !== void 0) throw runtimeError("unsupported", "Unsupported View query must be upgraded explicitly before editing");
1002
+ if (change.patch.query !== void 0 && hasEidosFileCalendarPeriodQuery(JSON.parse(current.query)) && request.calendarQueryVersion !== 2) throw runtimeError("unsupported", "This View requires a client that explicitly accepts calendar query version 2");
1003
+ if (change.patch.query !== void 0) {
1004
+ if (hasEidosFileCalendarWindowQuery(JSON.parse(current.query)) && request.calendarWindowVersion !== 1) throw runtimeError("unsupported", "This View requires a client that explicitly accepts calendar window version 1");
1005
+ }
1006
+ if (change.patch.query !== void 0) assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), change.patch.query);
915
1007
  const layout = change.patch.layout === void 0 ? void 0 : objectValue(change.patch.layout);
916
1008
  const fieldOrder = Array.isArray(layout?.fieldOrder) ? layout.fieldOrder.filter((fieldId) => typeof fieldId === "string") : null;
917
1009
  const hiddenFields = Array.isArray(layout?.hiddenFields) ? layout.hiddenFields.filter((fieldId) => typeof fieldId === "string") : [];
@@ -1044,6 +1136,38 @@ var EidosRuntimeService = class {
1044
1136
  return responseFor(dependencies);
1045
1137
  }, false, request);
1046
1138
  }
1139
+ initializeCliTable(change, context) {
1140
+ return this.invoke(context, () => {
1141
+ this.assertWritable("initializeCliTable");
1142
+ const createdObjects = [];
1143
+ let tableId = "";
1144
+ let viewId = "";
1145
+ this.core.applyCanonicalMutation(() => {
1146
+ const before = this.core.info();
1147
+ if (change.kind !== "create-table" || String(before.revision) !== "0" || before.defaultTableId != null || this.core.listTables().length !== 0 || this.core.connection.query("SELECT id FROM eidos__views").length !== 0) throw runtimeError("invalid-request", "Initial Table requires a fresh File at revision 0");
1148
+ if (this.analyzeSchemaChange(change).classification === "forbidden") throw runtimeError("forbidden", "Initial Table schema is forbidden");
1149
+ this.applySchemaChange(change, createdObjects, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
1150
+ tableId = createdObjects.find((object) => object.object === "table").id;
1151
+ this.applySchemaChange({
1152
+ kind: "set-default-table",
1153
+ tableId
1154
+ }, [], /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
1155
+ viewId = this.core.createView(tableId, {
1156
+ name: "Grid",
1157
+ type: "grid"
1158
+ }).id;
1159
+ }, 0n);
1160
+ return {
1161
+ schema: {
1162
+ revision: String(this.core.info().revision),
1163
+ changed: true,
1164
+ createdObjects: createdObjects.filter((object) => "clientKey" in object)
1165
+ },
1166
+ tableId,
1167
+ viewId
1168
+ };
1169
+ }, false, change);
1170
+ }
1047
1171
  async mutateSchema(request, context) {
1048
1172
  return this.invoke(context, () => {
1049
1173
  this.assertWritable("mutateSchema");
@@ -1143,11 +1267,11 @@ var EidosRuntimeService = class {
1143
1267
  tables: String(tables.length),
1144
1268
  fields: String(fields.length),
1145
1269
  views: String(views.length),
1146
- features: "0"
1270
+ features: String(this.core.connection.query("SELECT name FROM eidos__features").length)
1147
1271
  }
1148
1272
  };
1149
1273
  }
1150
- schemaDescriptors() {
1274
+ schemaDescriptors(calendarQueryVersion, calendarWindowVersion) {
1151
1275
  const tables = this.core.listTables();
1152
1276
  const tableSettings = new Map(this.core.connection.query("SELECT id, settings_json FROM eidos__tables").map((row) => [row.id, objectValue(JSON.parse(row.settings_json))]));
1153
1277
  const tableDescriptors = tables.map((table) => {
@@ -1162,26 +1286,41 @@ var EidosRuntimeService = class {
1162
1286
  settings: tableSettings.get(table.id) ?? {}
1163
1287
  };
1164
1288
  });
1165
- const fieldDescriptors = tables.flatMap((table) => this.core.listFields(table.id).map((field) => fieldDescriptor(field)));
1289
+ const fieldDescriptors = tables.flatMap((table) => this.core.listFields(table.id).map((field) => ({
1290
+ ...fieldDescriptor(field),
1291
+ writable: this.writable && fieldWritable(field)
1292
+ })));
1166
1293
  const views = tables.flatMap((table) => this.core.listViews(table.id).map((view) => ({
1167
1294
  object: "view",
1168
1295
  id: view.id,
1169
1296
  tableId: view.tableId,
1170
1297
  name: view.name,
1171
1298
  type: view.type,
1172
- queryStatus: view.queryStatus,
1173
- query: view.queryStatus === "unsupported" ? {} : {
1174
- ...view.filter ? { filter: compatibilityFilterToRuntime(view.filter, this.core.listFields(view.tableId)) } : {},
1175
- ...view.sorts.length > 0 ? { sort: view.sorts.map((sort) => ({
1176
- fieldId: sort.field,
1177
- direction: sort.direction,
1178
- ...sort.nulls ? { nulls: sort.nulls } : {}
1179
- })) } : {}
1299
+ ...view.queryStatus === "unsupported" || calendarWindowVersion !== 1 && hasEidosFileCalendarWindowQuery(JSON.parse(view.query)) || calendarQueryVersion !== 2 && hasEidosFileCalendarPeriodQuery(JSON.parse(view.query)) ? {
1300
+ queryStatus: "unsupported",
1301
+ query: objectValue(parseEidosFileJson(view.query))
1302
+ } : {
1303
+ queryStatus: "supported",
1304
+ query: isPublicSavedQueryDocument(JSON.parse(view.query)) ? JSON.parse(view.query) : {
1305
+ ...view.filter ? { filter: compatibilityFilterToRuntime(view.filter, this.core.listFields(view.tableId)) } : {},
1306
+ ...view.sorts.length > 0 ? { sort: view.sorts.map((sort) => ({
1307
+ fieldId: sort.field,
1308
+ direction: sort.direction,
1309
+ ...sort.nulls ? { nulls: sort.nulls } : {}
1310
+ })) } : {}
1311
+ }
1180
1312
  },
1181
1313
  layout: objectValue(view.properties ?? {}),
1182
1314
  position: String(view.position ?? 0)
1183
1315
  })));
1184
1316
  return [
1317
+ ...this.core.connection.query("SELECT name, version, required, config_json FROM eidos__features ORDER BY name").map((row) => ({
1318
+ object: "feature",
1319
+ name: row.name,
1320
+ version: row.version,
1321
+ required: row.required === 1,
1322
+ config: objectValue(JSON.parse(row.config_json))
1323
+ })),
1185
1324
  ...tableDescriptors,
1186
1325
  ...fieldDescriptors,
1187
1326
  ...views
@@ -1201,7 +1340,7 @@ var EidosRuntimeService = class {
1201
1340
  name: field.name,
1202
1341
  valueType: eidosFileFieldValueType(field),
1203
1342
  source: field.type === "formula" ? "formula" : field.type === "lookup" ? "lookup" : field.type === "relation" && relation?.direction === "inverse" ? "inverse-relation" : "stored",
1204
- writable: fieldWritable(field)
1343
+ writable: this.writable && fieldWritable(field)
1205
1344
  };
1206
1345
  });
1207
1346
  }
@@ -1261,7 +1400,8 @@ var EidosRuntimeService = class {
1261
1400
  results: request.items.map((item) => ({
1262
1401
  key: item.key,
1263
1402
  value: count
1264
- }))
1403
+ })),
1404
+ ...usesClockFilter(request.query?.filter) ? { referenceInstant: this.requestInstant } : {}
1265
1405
  };
1266
1406
  }
1267
1407
  const fields = this.core.listFields(request.tableId);
@@ -1319,14 +1459,29 @@ var EidosRuntimeService = class {
1319
1459
  fileId: metadata.fileId,
1320
1460
  tableId: request.tableId,
1321
1461
  revision: String(metadata.revision),
1322
- results
1462
+ results,
1463
+ ...usesClockFilter(request.query?.filter) ? { referenceInstant: this.requestInstant } : {}
1323
1464
  };
1324
1465
  }
1466
+ bindCursorReference(reference) {
1467
+ const instant = normalizeEidosFileInstant(reference);
1468
+ if (this.requestedReference !== void 0 && this.requestedReference !== instant) throw runtimeError("invalid-query", "Cursor reference instant mismatch");
1469
+ this.requestInstant = instant;
1470
+ this.core.setRequestInstant(instant);
1471
+ }
1325
1472
  compatibilityQuery(tableId, query) {
1326
1473
  assertRuntimeRowQuery(this.core.listFields(tableId), query);
1327
- return runtimeQueryToCompatibility(query);
1474
+ if (usesCalendarPeriod(query.filter)) assertEidosFileCalendarContext(this.requestCalendar);
1475
+ return {
1476
+ ...runtimeQueryToCompatibility(query),
1477
+ ...this.requestCalendar ? { calendar: this.requestCalendar } : {}
1478
+ };
1328
1479
  }
1329
1480
  async groupRowsNow(request) {
1481
+ if (request.cursor) {
1482
+ const cursor = this.decodeCursor(request.cursor, "groups");
1483
+ if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
1484
+ }
1330
1485
  assertLimit(request.groupLimit, EIDOS_RUNTIME_LIMITS.groupPageSizeMax, "groupLimit");
1331
1486
  assertLimit(request.rowsPerGroup, EIDOS_RUNTIME_LIMITS.pageSizeMax, "rowsPerGroup");
1332
1487
  if (request.groupBy.length < 1 || request.groupBy.length > EIDOS_RUNTIME_LIMITS.groupFieldsMax || new Set(request.groupBy).size !== request.groupBy.length) throw runtimeError("invalid-query", "groupBy is invalid");
@@ -1389,7 +1544,8 @@ var EidosRuntimeService = class {
1389
1544
  revision: String(metadata.revision),
1390
1545
  projectionHash: projectionDigest,
1391
1546
  bindingHash: bindingDigest,
1392
- groupIdentity: group.identity
1547
+ groupIdentity: group.identity,
1548
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment)
1393
1549
  }) : null;
1394
1550
  return {
1395
1551
  fileId: metadata.fileId,
@@ -1397,6 +1553,7 @@ var EidosRuntimeService = class {
1397
1553
  revision: String(metadata.revision),
1398
1554
  projectionHash: projectionDigest,
1399
1555
  columns,
1556
+ ...usesClockFilter(request.query.filter) ? { referenceInstant: this.requestInstant } : {},
1400
1557
  groups: selected.map((group) => {
1401
1558
  const visible = group.rows.slice(0, request.rowsPerGroup);
1402
1559
  const projected = visible.map((row) => projectionRows.get(row.id) ?? row);
@@ -1410,6 +1567,7 @@ var EidosRuntimeService = class {
1410
1567
  bindingHash: bindingDigest,
1411
1568
  request: groupCursorSource(request),
1412
1569
  groupKey: group.key,
1570
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
1413
1571
  forward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, groupedQuery), row),
1414
1572
  backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardGroupedQuery), row)
1415
1573
  });
@@ -1457,7 +1615,8 @@ var EidosRuntimeService = class {
1457
1615
  revision: String(metadata.revision),
1458
1616
  projectionHash: projectionDigest,
1459
1617
  bindingHash: bindingDigest,
1460
- groupIdentity: group.identity
1618
+ groupIdentity: group.identity,
1619
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment)
1461
1620
  }) : null;
1462
1621
  const groups = selected.map((group) => {
1463
1622
  const groupedQuery = queryForGroup(request.query, request.groupBy, group.key);
@@ -1479,6 +1638,7 @@ var EidosRuntimeService = class {
1479
1638
  bindingHash: bindingDigest,
1480
1639
  request: groupCursorSource(request),
1481
1640
  groupKey: group.key,
1641
+ referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
1482
1642
  forward: this.core.createRowCursor(request.tableId, compatibilityQuery, row),
1483
1643
  backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardGroupedQuery), row)
1484
1644
  });
@@ -1496,6 +1656,7 @@ var EidosRuntimeService = class {
1496
1656
  revision: String(metadata.revision),
1497
1657
  projectionHash: projectionDigest,
1498
1658
  columns,
1659
+ ...usesClockFilter(request.query.filter) ? { referenceInstant: this.requestInstant } : {},
1499
1660
  groups,
1500
1661
  nextCursor: end < counts.length ? cursorForGroup(selected.at(-1)) : null,
1501
1662
  previousCursor: start > 0 ? cursorForGroup(selected[0]) : null
@@ -1735,6 +1896,7 @@ var EidosRuntimeService = class {
1735
1896
  if ("position" in leaf) parseSignedInt64(leaf.position, "position");
1736
1897
  switch (leaf.kind) {
1737
1898
  case "create-table":
1899
+ for (const field of leaf.fields) assertEidosFileTemporalDefault(field.kind, field.settings, field.settings?.readOnly !== true && field.settings?.writable !== false && field.settings?.isSystem !== true);
1738
1900
  if (leaf.fields.some((field) => field.kind === "relation" || field.kind === "lookup")) forbid("relation-definition-invalid", "Relation and Lookup Fields cannot be created inside create-table");
1739
1901
  break;
1740
1902
  case "set-file-title":
@@ -1777,8 +1939,9 @@ var EidosRuntimeService = class {
1777
1939
  }
1778
1940
  break;
1779
1941
  case "create-field":
1942
+ assertEidosFileTemporalDefault(leaf.field.kind, leaf.field.settings, leaf.field.settings?.readOnly !== true && leaf.field.settings?.writable !== false && leaf.field.settings?.isSystem !== true);
1780
1943
  if (!tableIds.has(leaf.tableId)) forbid("dependency-blocked", "Owning Table does not exist", { tableId: leaf.tableId });
1781
- if (leaf.field.kind !== "formula" && leaf.field.kind !== "lookup" && leaf.field.kind !== "relation" && leaf.field.nullable === false && this.core.countRows(leaf.tableId) > 0) forbid("non-nullability-blocked", "A populated Table cannot add a non-null scalar Field", { tableId: leaf.tableId });
1944
+ if (leaf.field.kind !== "formula" && leaf.field.kind !== "lookup" && leaf.field.kind !== "relation" && leaf.field.kind !== "checkbox" && leaf.field.nullable === false && this.core.countRows(leaf.tableId) > 0) forbid("non-nullability-blocked", "A populated Table cannot add a non-null scalar Field", { tableId: leaf.tableId });
1782
1945
  break;
1783
1946
  case "delete-field": {
1784
1947
  const field = fieldsById.get(leaf.fieldId);
@@ -1814,8 +1977,16 @@ var EidosRuntimeService = class {
1814
1977
  }
1815
1978
  break;
1816
1979
  }
1980
+ case "set-field-settings": {
1981
+ const field = proposedFields.get(leaf.fieldId);
1982
+ if (field) assertEidosFileTemporalDefault(field.type, {
1983
+ ...field.settings,
1984
+ ...leaf.settings
1985
+ }, fieldWritable(field));
1986
+ if (!fieldsById.has(leaf.fieldId)) forbid("dependency-blocked", "Field does not exist", { fieldId: leaf.fieldId });
1987
+ break;
1988
+ }
1817
1989
  case "rename-field":
1818
- case "set-field-settings":
1819
1990
  case "set-field-position":
1820
1991
  case "set-formula":
1821
1992
  case "set-lookup":
@@ -1974,10 +2145,47 @@ var EidosRuntimeService = class {
1974
2145
  tableId: field.tableId,
1975
2146
  fieldId: leaf.fieldId
1976
2147
  })));
2148
+ const nullToFalse = conversion.valueChanges.find((change) => change.code === "null-to-false");
2149
+ if (nullToFalse) warnings.push({
2150
+ code: "null-distinction-loss",
2151
+ severity: "warning",
2152
+ tableId: field.tableId,
2153
+ fieldId: leaf.fieldId,
2154
+ message: `${nullToFalse.rows} empty cells in this column will become unchecked.`
2155
+ });
1977
2156
  break;
1978
2157
  }
1979
2158
  }
1980
2159
  }
2160
+ const changedQueryFields = fields.filter((field) => {
2161
+ const proposed = proposedFields.get(field.id);
2162
+ return proposed && canonicalizeEidosFileJson(eidosFileFieldValueType(field)) !== canonicalizeEidosFileJson(eidosFileFieldValueType(proposed));
2163
+ });
2164
+ if (changedQueryFields.length > 0) for (const view of this.allViews()) {
2165
+ if (view.queryStatus === "unsupported") continue;
2166
+ const dependency = changedQueryFields.find((field) => field.tableId === view.tableId && (view.sorts.some((sort) => sort.field === field.id) || compatibilityFilterReferencesField(view.filter, field.id)));
2167
+ if (!dependency) continue;
2168
+ dependencies.set("view:" + view.id, {
2169
+ object: "view",
2170
+ id: view.id
2171
+ });
2172
+ try {
2173
+ assertRuntimeRowQuery(proposedByTable.get(view.tableId) ?? [], {
2174
+ ...view.filter ? { filter: compatibilityFilterToRuntime(view.filter, fields) } : {},
2175
+ sort: view.sorts.map((sort) => ({
2176
+ fieldId: sort.field,
2177
+ direction: sort.direction,
2178
+ ...sort.nulls ? { nulls: sort.nulls } : {}
2179
+ }))
2180
+ });
2181
+ } catch {
2182
+ forbid("dependency-blocked", `Saved View “${view.name}” has a filter or sort that is incompatible with the new field type. Update or remove it before changing the field type.`, {
2183
+ tableId: view.tableId,
2184
+ fieldId: dependency.id,
2185
+ viewId: view.id
2186
+ });
2187
+ }
2188
+ }
1981
2189
  for (const [tableId, contentFieldId] of proposedContentFields) {
1982
2190
  if (contentFieldId === null) continue;
1983
2191
  const field = proposedFields.get(contentFieldId);
@@ -2173,6 +2381,7 @@ var EidosRuntimeService = class {
2173
2381
  ...field.settings ?? {},
2174
2382
  ...leaf.settings
2175
2383
  };
2384
+ if (assertEidosFileTemporalDefault(field.type, settings, fieldWritable(field)) === "now") enableTemporalDefaultsFeature(this.core.connection);
2176
2385
  this.core.connection.run("UPDATE eidos__fields SET settings_json=? WHERE id=? AND settings_json IS NOT ?", [
2177
2386
  canonicalizeEidosFileJson(settings),
2178
2387
  leaf.fieldId,
@@ -2349,7 +2558,7 @@ var EidosRuntimeService = class {
2349
2558
  assertWritable(operation) {
2350
2559
  if (!this.writable) throw runtimeError("unsupported", operation + " is unavailable read-only");
2351
2560
  }
2352
- invoke(context, operation, allowClosing = false, requestPayload, accountResponse = true) {
2561
+ invoke(context, operation, allowClosing = false, requestPayload, accountResponse = true, acceptCalendarExecution = false, checkReadCompletion = false) {
2353
2562
  try {
2354
2563
  assertRequestContext(context);
2355
2564
  if (requestPayload !== void 0) assertJcsBytes(requestPayload, EIDOS_RUNTIME_LIMITS.requestBytesMax, "Runtime request");
@@ -2370,7 +2579,16 @@ var EidosRuntimeService = class {
2370
2579
  const execute = async () => {
2371
2580
  try {
2372
2581
  if (!allowClosing) this.checkControl(context, control, acceptedAt);
2582
+ const calendar = acceptCalendarExecution && requestPayload && typeof requestPayload === "object" && "calendar" in requestPayload ? requestPayload.calendar : void 0;
2583
+ if (calendar !== void 0) assertEidosFileCalendarContext(calendar);
2584
+ this.requestCalendar = calendar;
2585
+ const reference = acceptCalendarExecution && requestPayload && typeof requestPayload === "object" && "referenceInstant" in requestPayload ? requestPayload.referenceInstant : void 0;
2586
+ if (reference !== void 0 && !isCanonicalEidosFileInstant(reference)) throw runtimeError("invalid-query", "referenceInstant must be a canonical UTC instant");
2587
+ this.requestedReference = reference;
2588
+ this.requestInstant = reference ?? checkedNowInstant(this.environment);
2589
+ this.core.setRequestInstant(this.requestInstant);
2373
2590
  const result = await operation();
2591
+ if (checkReadCompletion) this.checkControl(context, control, acceptedAt);
2374
2592
  if (result !== void 0 && accountResponse) assertJcsBytes(result, EIDOS_RUNTIME_LIMITS.responseBytesMax, "Runtime response");
2375
2593
  return result;
2376
2594
  } catch (error) {
@@ -2378,6 +2596,10 @@ var EidosRuntimeService = class {
2378
2596
  if (failure.code === "fatal" || failure.code === "unknown-commit") this.state = "fatal";
2379
2597
  throw failure;
2380
2598
  } finally {
2599
+ this.core.setRequestInstant();
2600
+ this.requestInstant = void 0;
2601
+ this.requestCalendar = void 0;
2602
+ this.requestedReference = void 0;
2381
2603
  control.unsubscribe();
2382
2604
  this.requestControls.delete(context.requestId);
2383
2605
  }
@@ -2482,6 +2704,29 @@ function relationDefinition(field) {
2482
2704
  ].includes(String(field.property.onDelete)) ? field.property.onDelete : "restrict"
2483
2705
  };
2484
2706
  }
2707
+ function usesCalendarPeriod(node) {
2708
+ if (!node) return false;
2709
+ if (node.op === "calendar-period" || node.op === "calendar-window") return true;
2710
+ if (node.op === "not") return usesCalendarPeriod(node.arg);
2711
+ return (node.op === "and" || node.op === "or") && node.args.some(usesCalendarPeriod);
2712
+ }
2713
+ function usesClockFilter(node) {
2714
+ if (!node) return false;
2715
+ if (node.op === "calendar-period" || node.op === "calendar-window") return true;
2716
+ if (node.op === "not") return usesClockFilter(node.arg);
2717
+ if (node.op === "and" || node.op === "or") return node.args.some(usesClockFilter);
2718
+ return false;
2719
+ }
2720
+ function isPublicSavedQueryDocument(query) {
2721
+ const visit = (value) => {
2722
+ if (!value || typeof value !== "object" || Array.isArray(value)) return false;
2723
+ const node = value;
2724
+ if (node.op === "not") return visit(node.arg);
2725
+ if (node.op === "and" || node.op === "or") return Array.isArray(node.args) && node.args.every(visit);
2726
+ return typeof node.fieldId === "string";
2727
+ };
2728
+ return (query.filter === void 0 || visit(query.filter)) && (query.sort === void 0 || Array.isArray(query.sort) && query.sort.every((sort) => sort && typeof sort === "object" && typeof sort.fieldId === "string"));
2729
+ }
2485
2730
  function normalizedRuntimeQuery(query) {
2486
2731
  return objectValue({
2487
2732
  ...query.filter === void 0 ? {} : { filter: query.filter },
@@ -2559,8 +2804,17 @@ function runtimeListElementType(type) {
2559
2804
  if (type === "relation") return "row-id";
2560
2805
  if (type === "file") return "file-entry";
2561
2806
  }
2807
+ function assertRuntimeSavedViewQuery(fields, query) {
2808
+ if (!query || typeof query !== "object" || Array.isArray(query) || Object.keys(query).some((key) => key !== "filter" && key !== "sort")) throw runtimeError("invalid-query", "SavedViewQuery contains execution settings or unknown members");
2809
+ assertRuntimeRowQuery(fields, query);
2810
+ }
2562
2811
  function assertRuntimeRowQuery(fields, query) {
2563
2812
  if (!query || typeof query !== "object" || Array.isArray(query)) throw runtimeError("invalid-query", "RowQuery must be an object");
2813
+ if (Object.keys(query).some((key) => ![
2814
+ "filter",
2815
+ "search",
2816
+ "sort"
2817
+ ].includes(key))) throw runtimeError("invalid-query", "Execution settings do not belong in RowQuery");
2564
2818
  const byId = new Map(fields.map((field) => [field.id, field]));
2565
2819
  if (query.search !== void 0) {
2566
2820
  if (typeof query.search.text !== "string" || new TextEncoder().encode(query.search.text).byteLength > EIDOS_RUNTIME_LIMITS.searchBytesMax || !Array.isArray(query.search.fields) || query.search.fields.length < 1 || query.search.fields.length > EIDOS_RUNTIME_LIMITS.projectionFieldsMax || new Set(query.search.fields).size !== query.search.fields.length) throw runtimeError("invalid-query", "Search request is invalid");
@@ -2597,9 +2851,56 @@ function assertRuntimeRowQuery(fields, query) {
2597
2851
  if (!field) throw runtimeError("invalid-query", "Filter Field does not exist", { fieldId: node.fieldId });
2598
2852
  const type = eidosFileFieldValueType(field);
2599
2853
  if (node.op === "is-null" || node.op === "is-not-null") return;
2854
+ if (node.op === "calendar-window") {
2855
+ if (type !== "date" && type !== "datetime" || !isEidosFileCalendarWindowValue({
2856
+ direction: node.direction,
2857
+ unit: node.unit,
2858
+ count: node.count
2859
+ }) || Object.keys(node).some((key) => ![
2860
+ "op",
2861
+ "fieldId",
2862
+ "direction",
2863
+ "unit",
2864
+ "count"
2865
+ ].includes(key))) throw runtimeError("invalid-query", "Calendar window Filter is invalid");
2866
+ return;
2867
+ }
2868
+ if (node.op === "calendar-period") {
2869
+ if (type !== "date" && type !== "datetime" || !isEidosFileCalendarPeriodValue({
2870
+ unit: node.unit,
2871
+ offset: node.offset
2872
+ }) || Object.keys(node).some((key) => ![
2873
+ "op",
2874
+ "fieldId",
2875
+ "unit",
2876
+ "offset"
2877
+ ].includes(key))) throw runtimeError("invalid-query", "Calendar period Filter is invalid");
2878
+ return;
2879
+ }
2880
+ if (node.op === "calendar-day") {
2881
+ const { day, timeZone, timeZoneData } = node;
2882
+ if (type !== "date" && type !== "datetime" || !isEidosFileCalendarDayValue({
2883
+ day,
2884
+ timeZone,
2885
+ timeZoneData
2886
+ }) || Object.keys(node).some((key) => ![
2887
+ "op",
2888
+ "fieldId",
2889
+ "day",
2890
+ "timeZone",
2891
+ "timeZoneData"
2892
+ ].includes(key))) throw runtimeError("invalid-query", "Calendar day Filter is invalid");
2893
+ assertEidosFileCalendarZone(timeZone, timeZoneData);
2894
+ throw runtimeError("unsupported", "Retired calendar-day query requires an explicit date filter upgrade");
2895
+ }
2600
2896
  if (node.op === "relative-date") {
2601
2897
  if (type !== "date" && type !== "datetime") throw runtimeError("invalid-query", "Relative date Filter requires Date or Datetime");
2602
- if (![
2898
+ if (Object.keys(node).some((key) => ![
2899
+ "op",
2900
+ "fieldId",
2901
+ "direction",
2902
+ "unit"
2903
+ ].includes(key)) || ![
2603
2904
  "past",
2604
2905
  "next",
2605
2906
  "this"
@@ -2609,7 +2910,7 @@ function assertRuntimeRowQuery(fields, query) {
2609
2910
  "month",
2610
2911
  "year"
2611
2912
  ].includes(node.unit)) throw runtimeError("invalid-query", "Relative date Filter direction or unit is invalid");
2612
- return;
2913
+ throw runtimeError("unsupported", "Retired relative-date query requires an explicit date filter upgrade");
2613
2914
  }
2614
2915
  if (node.op === "contains" || node.op === "starts-with" || node.op === "ends-with") {
2615
2916
  if (typeof type !== "string" || ![
@@ -2712,6 +3013,35 @@ function runtimeFilterNodeToCompatibility(node) {
2712
3013
  operator: "is-between",
2713
3014
  value: [node.lower, node.upper]
2714
3015
  };
3016
+ if (node.op === "calendar-window") return {
3017
+ type: "rule",
3018
+ field: node.fieldId,
3019
+ operator: "is-in-calendar-window",
3020
+ value: {
3021
+ direction: node.direction,
3022
+ count: node.count,
3023
+ unit: node.unit
3024
+ }
3025
+ };
3026
+ if (node.op === "calendar-period") return {
3027
+ type: "rule",
3028
+ field: node.fieldId,
3029
+ operator: "is-in-calendar-period",
3030
+ value: {
3031
+ unit: node.unit,
3032
+ offset: node.offset
3033
+ }
3034
+ };
3035
+ if (node.op === "calendar-day") return {
3036
+ type: "rule",
3037
+ field: node.fieldId,
3038
+ operator: "is-on-calendar-day",
3039
+ value: {
3040
+ day: node.day,
3041
+ timeZone: node.timeZone,
3042
+ timeZoneData: node.timeZoneData
3043
+ }
3044
+ };
2715
3045
  if (node.op === "relative-date") return {
2716
3046
  type: "rule",
2717
3047
  field: node.fieldId,
@@ -2799,6 +3129,30 @@ function compatibilityFilterRuleToRuntime(rule, fields) {
2799
3129
  fieldId: rule.field,
2800
3130
  values: requireValues()
2801
3131
  };
3132
+ if (rule.operator === "is-in-calendar-window") {
3133
+ if (!isEidosFileCalendarWindowValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar window is invalid");
3134
+ return {
3135
+ op: "calendar-window",
3136
+ fieldId: rule.field,
3137
+ ...rule.value
3138
+ };
3139
+ }
3140
+ if (rule.operator === "is-in-calendar-period") {
3141
+ if (!isEidosFileCalendarPeriodValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar period is invalid");
3142
+ return {
3143
+ op: "calendar-period",
3144
+ fieldId: rule.field,
3145
+ ...rule.value
3146
+ };
3147
+ }
3148
+ if (rule.operator === "is-on-calendar-day") {
3149
+ if (!isEidosFileCalendarDayValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar day filter is invalid");
3150
+ return {
3151
+ op: "calendar-day",
3152
+ fieldId: rule.field,
3153
+ ...rule.value
3154
+ };
3155
+ }
2802
3156
  if (rule.operator === "is-relative-to-today") {
2803
3157
  const relative = rule.value;
2804
3158
  if (!relative || ![
@@ -3059,7 +3413,7 @@ function simulatedNewField(tableId, tableName, field, sequence) {
3059
3413
  tableColumnName: virtual ? id : field.name,
3060
3414
  physicalName: virtual ? null : field.name,
3061
3415
  systemRole: null,
3062
- nullable: field.kind === "formula" || field.kind === "lookup" ? true : list || field.kind === "relation" ? false : field.nullable !== false,
3416
+ nullable: field.kind === "formula" || field.kind === "lookup" ? true : list || field.kind === "relation" ? false : field.kind === "checkbox" ? field.nullable === true : field.nullable !== false,
3063
3417
  isRecordLabel: false,
3064
3418
  position: Number(field.position),
3065
3419
  settings: field.settings ?? {},
@@ -3397,6 +3751,7 @@ function compareGroupKeys(left, right, types) {
3397
3751
  function groupCursorSource(request) {
3398
3752
  return objectValue({
3399
3753
  tableId: request.tableId,
3754
+ ...request.calendar ? { calendar: request.calendar } : {},
3400
3755
  query: normalizedRuntimeQuery(request.query),
3401
3756
  groupBy: request.groupBy,
3402
3757
  aggregates: request.aggregates,
@@ -3428,6 +3783,7 @@ function queryForGroup(query, groupBy, key) {
3428
3783
  function groupBindingHash(request) {
3429
3784
  return hashJson({
3430
3785
  tableId: request.tableId,
3786
+ ...request.calendar ? { calendar: request.calendar } : {},
3431
3787
  query: normalizedRuntimeQuery(request.query),
3432
3788
  groupBy: request.groupBy,
3433
3789
  aggregates: request.aggregates,
@@ -3614,6 +3970,6 @@ function jcsByteLength(value) {
3614
3970
  return new TextEncoder().encode(canonicalizeEidosFileJson(value)).byteLength;
3615
3971
  }
3616
3972
  //#endregion
3617
- export { AdapterTransportRuntimeClient, AdapterTransportServer, ConnectionPortEidosFileConnection, EIDOS_ADAPTER_TRANSPORT_LIMITS, EIDOS_FILE_APPLICATION_ID, EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, EIDOS_FILE_EXTENSION, EIDOS_FILE_FEATURES_TABLE, EIDOS_FILE_FIELDS_TABLE, EIDOS_FILE_FORMAT, EIDOS_FILE_FORMAT_VERSION, EIDOS_FILE_FORMAT_VERSION_TEXT, EIDOS_FILE_FORMULA_FIELDS_TABLE, EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, EIDOS_FILE_FORMULA_FUNCTION_NAMES, EIDOS_FILE_FORMULA_PROFILE, EIDOS_FILE_FORM_INPUT_FIELD_TYPES, EIDOS_FILE_FORM_VIEW_TYPE, EIDOS_FILE_LOOKUP_FIELDS_TABLE, EIDOS_FILE_META_TABLE, EIDOS_FILE_MIME_TYPE, EIDOS_FILE_RELATION_FIELDS_TABLE, EIDOS_FILE_REQUIRED_TABLES, EIDOS_FILE_SCHEMA_SQL, EIDOS_FILE_SCHEMA_VERSION, EIDOS_FILE_SYSTEM_COLUMNS, EIDOS_FILE_TABLES_TABLE, EIDOS_FILE_VIEWS_TABLE, EIDOS_RUNTIME_LIMITS, EIDOS_SYSTEM_METADATA_TABLES, EidosAdapterError, EidosFileError, EidosFileHandlerRegistry, EidosFileHostError, EidosFileRuntime, EidosFileRuntimeDataSource, EidosFileSession, EidosRuntimeService, EidosUuidV7Generator, MUTABLE_BASE_FIELD_TYPES, MemoryByteSource, Runtime, SQLITE_HEADER, SQLiteWasmConnectionPort, assertEidosFileColumnName, assertEidosFileDisplayName, assertEidosFileFormulaProfile, assertEidosFileMultiSelectHasNoDefaultOption, assertEidosFileRowQuery, assertEidosFileSelectDefaultOption, assertEidosFileSelectOptions, assertEidosFileTableId, assertEidosFileTableName, assertEidosFileUuid, assertEidosFileValues, assertInt64Decimal, assertUnicodeString, cancellationPortFromSignal, canonicalizeEidosFileJson, compileEidosFileFormula, compileEidosFileFormulaFields, compileEidosFileFormulaSource, compileEidosFileRowQuery, configureEidosFileConnection, configuredTypeRef, createEidosFileCsvImportPlan, createEidosFileCsvRowEncoder, createEidosFileIdentifier, createEidosFileUuid, currentEidosFileInstant, decodeEidosFileAttachmentPaths, decodeEidosFileJsonArray, decodeEidosFileMultiSelectValues, decodeEidosFileRelationDisplay, decodeEidosFileRelationIds, decodeEidosFileStringArray, decodeEidosFileValues, eidosFileColumnStatLabel, eidosFileColumnStatTypesForField, eidosFileConversionCanReusePhysicalColumn, eidosFileConversionTargetNullable, eidosFileCsvExportHeader, eidosFileCsvRowToEidosFileRow, eidosFileFieldConversionMayRequireLossyConfirmation, eidosFileFieldDisplayValues, eidosFileFieldQueryCapabilities, eidosFileFieldStoresJsonArray, eidosFileFieldValueType, eidosFileFormViewFields, eidosFileFormViewProperties, eidosFileFormulaReferences, eidosFileLookupAggregateSupportsTarget, eidosFileLookupDisplayType, eidosFileLookupElementType, eidosFileLookupStorageCodec, eidosFileLookupTargetDisplayType, eidosFileLookupTargetValueType, eidosFileLookupValueType, eidosFileRowQueryAffectedByFieldChanges, eidosFileRowQueryPredicateColumns, eidosFileRowQuerySearchFields, eidosFileSnapshot, eidosFileSortExpression, eidosFileTextMultiSelectChoices, eidosFileTypeHandler, eidosFileTypeRefQueryCapabilities, eidosFileUriClass, encodeEidosFileAttachmentPaths, encodeEidosFileCsvRecord, encodeEidosFileJsonArray, encodeEidosFileMultiSelectValues, encodeEidosFileRelationIds, encodeEidosFileValues, hasEidosFileSqliteHeader, importEidosFileCsv, incrementEidosFileRevision, initializeEidosFileSchema, isCanonicalEidosFileDate, isCanonicalEidosFileInstant, isCanonicalEidosFileJson, isEidosFileFilterOperator, isEidosFileFormInputField, isEidosFileReservedTableName, isEidosFileUriReference, isEidosFileUuid, isMutableEidosFileFieldType, isSafeEidosFileUri, mergeEidosFilePluginConfig, mergeEidosSystemMetadata, nativeToSqlValue, normalizeEidosFileAttachmentPath, normalizeEidosFileDate, normalizeEidosFileFilter, normalizeEidosFileInstant, normalizeEidosFileRowQuery, normalizeEidosFileSorts, parseEidosFileCsvRows, parseEidosFileJson, parseEidosFileSelectDefaultOption, parseEidosFileSelectOptions, parseNonNegativeInt64, planCanonicalFieldConversion, planEidosFileCsvImport, planEidosFileFieldConversion, prepareEidosFileCsvImport, quoteIdentifier, readEidosFilePluginConfig, recommendedEidosFileConversionPolicies, removeEidosFileFilterField, rewriteEidosFileFormulaFieldReferences, setEidosFileMetadata, sqlValueToNative, transportFitsHostLimit, validateAdapterCarrier, validateAdapterEnvelope, validateEidosFile };
3973
+ export { AdapterTransportRuntimeClient, AdapterTransportServer, ConnectionPortEidosFileConnection, EIDOS_ADAPTER_TRANSPORT_LIMITS, EIDOS_FILE_APPLICATION_ID, EIDOS_FILE_CALENDAR_MAX_YEAR, EIDOS_FILE_CALENDAR_MIN_YEAR, EIDOS_FILE_CALENDAR_TIME_ZONE_DATA, EIDOS_FILE_CALENDAR_WINDOW_COUNT_MAX, EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT, EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT_MAX_BYTES, EIDOS_FILE_EXTENSION, EIDOS_FILE_FEATURES_TABLE, EIDOS_FILE_FIELDS_TABLE, EIDOS_FILE_FORMAT, EIDOS_FILE_FORMAT_VERSION, EIDOS_FILE_FORMAT_VERSION_TEXT, EIDOS_FILE_FORMULA_FIELDS_TABLE, EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, EIDOS_FILE_FORMULA_FUNCTION_NAMES, EIDOS_FILE_FORMULA_PROFILE, EIDOS_FILE_FORM_INPUT_FIELD_TYPES, EIDOS_FILE_FORM_VIEW_TYPE, EIDOS_FILE_LOOKUP_FIELDS_TABLE, EIDOS_FILE_META_TABLE, EIDOS_FILE_MIME_TYPE, EIDOS_FILE_RELATION_FIELDS_TABLE, EIDOS_FILE_REQUIRED_TABLES, EIDOS_FILE_SCHEMA_SQL, EIDOS_FILE_SCHEMA_VERSION, EIDOS_FILE_SYSTEM_COLUMNS, EIDOS_FILE_TABLES_TABLE, EIDOS_FILE_VIEWS_TABLE, EIDOS_RUNTIME_LIMITS, EIDOS_SYSTEM_METADATA_TABLES, EidosAdapterError, EidosFileError, EidosFileHandlerRegistry, EidosFileHostError, EidosFileRuntime, EidosFileRuntimeDataSource, EidosFileSession, EidosRuntimeService, EidosUuidV7Generator, MUTABLE_BASE_FIELD_TYPES, MemoryByteSource, Runtime, SQLITE_HEADER, SQLiteWasmConnectionPort, assertEidosFileCalendarContext, assertEidosFileCalendarZone, assertEidosFileColumnName, assertEidosFileDisplayName, assertEidosFileFormulaProfile, assertEidosFileMultiSelectHasNoDefaultOption, assertEidosFileRowQuery, assertEidosFileSelectDefaultOption, assertEidosFileSelectOptions, assertEidosFileTableId, assertEidosFileTableName, assertEidosFileTemporalDefault, assertEidosFileUuid, assertEidosFileValues, assertInt64Decimal, assertUnicodeString, cancellationPortFromSignal, canonicalizeEidosFileJson, compileEidosFileFormula, compileEidosFileFormulaFields, compileEidosFileFormulaSource, compileEidosFileRowQuery, configureEidosFileConnection, configuredTypeRef, createEidosFileCsvImportPlan, createEidosFileCsvRowEncoder, createEidosFileIdentifier, createEidosFileUuid, currentEidosFileInstant, decodeEidosFileAttachmentPaths, decodeEidosFileJsonArray, decodeEidosFileMultiSelectValues, decodeEidosFileRelationDisplay, decodeEidosFileRelationIds, decodeEidosFileStringArray, decodeEidosFileValues, eidosFileCalendarDateRangeIntervals, eidosFileCalendarDayBounds, eidosFileCalendarPeriodBounds, eidosFileCalendarTimeZones, eidosFileCalendarWindowBounds, eidosFileColumnStatLabel, eidosFileColumnStatTypesForField, eidosFileConversionCanReusePhysicalColumn, eidosFileConversionTargetNullable, eidosFileCsvExportHeader, eidosFileCsvRowToEidosFileRow, eidosFileDateQueryUpgradeReceipt, eidosFileFieldConversionMayRequireLossyConfirmation, eidosFileFieldDisplayValues, eidosFileFieldQueryCapabilities, eidosFileFieldStoresJsonArray, eidosFileFieldValueType, eidosFileFormViewFields, eidosFileFormViewProperties, eidosFileFormulaReferences, eidosFileLookupAggregateSupportsTarget, eidosFileLookupDisplayType, eidosFileLookupElementType, eidosFileLookupStorageCodec, eidosFileLookupTargetDisplayType, eidosFileLookupTargetValueType, eidosFileLookupValueType, eidosFileRowQueryAffectedByFieldChanges, eidosFileRowQueryPredicateColumns, eidosFileRowQuerySearchFields, eidosFileSnapshot, eidosFileSortExpression, eidosFileTemporalDefaultValue, eidosFileTextMultiSelectChoices, eidosFileTypeHandler, eidosFileTypeRefQueryCapabilities, eidosFileUriClass, encodeEidosFileAttachmentPaths, encodeEidosFileCsvRecord, encodeEidosFileJsonArray, encodeEidosFileMultiSelectValues, encodeEidosFileRelationIds, encodeEidosFileValues, hasEidosFileCalendarPeriodQuery, hasEidosFileCalendarQuery, hasEidosFileCalendarWindowQuery, hasEidosFileSqliteHeader, hasRetiredEidosFileDateQuery, importEidosFileCsv, incrementEidosFileRevision, initializeEidosFileSchema, isCanonicalEidosFileDate, isCanonicalEidosFileInstant, isCanonicalEidosFileJson, isEidosFileCalendarDayValue, isEidosFileCalendarPeriodValue, isEidosFileCalendarWindowValue, isEidosFileFilterOperator, isEidosFileFormInputField, isEidosFileReservedTableName, isEidosFileUriReference, isEidosFileUuid, isMutableEidosFileFieldType, isSafeEidosFileUri, mergeEidosFilePluginConfig, mergeEidosSystemMetadata, nativeToSqlValue, normalizeEidosFileAttachmentPath, normalizeEidosFileDate, normalizeEidosFileFilter, normalizeEidosFileInstant, normalizeEidosFileRowQuery, normalizeEidosFileSorts, normalizeEidosSchemaMerge, parseEidosFileCsvRows, parseEidosFileJson, parseEidosFileSelectDefaultOption, parseEidosFileSelectOptions, parseNonNegativeInt64, planCanonicalFieldConversion, planEidosFileCsvImport, planEidosFileFieldConversion, planEidosSchemaMerge, prepareEidosFileCsvImport, projectEidosFileCalendarInstant, quoteIdentifier, readEidosFilePluginConfig, recommendedEidosFileConversionPolicies, removeEidosFileFilterField, resolveEidosFileCalendarInstant, rewriteEidosFileFormulaFieldReferences, setEidosFileMetadata, sqlValueToNative, supportsEidosFileCalendarProfile, transportFitsHostLimit, upgradeEidosFileDateQuery, validateAdapterCarrier, validateAdapterEnvelope, validateEidosFile };
3618
3974
 
3619
3975
  //# sourceMappingURL=index.mjs.map