@deepexi/datasense-connector 3.0.1 → 3.1.0

package/cjs/index.cjs

@@ -1,1015 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  ConnectorError: () => ConnectorError,
-  DEFAULT_PUSH_NAME: () => DEFAULT_PUSH_NAME,
-  PNG_DATA_URI_PREFIX: () => PNG_DATA_URI_PREFIX,
-  PRESENTATION_LIMITS: () => PRESENTATION_LIMITS,
-  RESERVED_PUSH_NAMES: () => RESERVED_PUSH_NAMES,
-  SDK_NAME_PATTERN: () => SDK_NAME_PATTERN,
-  SDK_VERSION: () => SDK_VERSION,
-  SUPPORTED_SDK_MAJORS: () => SUPPORTED_SDK_MAJORS,
-  decodeConnectorIcon: () => decodeConnectorIcon,
-  defineConnector: () => defineConnector,
-  errors: () => errors,
-  normalizeDiscoverResult: () => normalizeDiscoverResult,
-  readConnectorPresentation: () => readConnectorPresentation,
-  summarizeDefinition: () => summarizeDefinition,
-  t: () => t,
-  validateConfig: () => validateConfig,
-  validateConnectorDefinition: () => validateConnectorDefinition,
-  validateDiscoverResult: () => validateDiscoverResult
-});
-module.exports = __toCommonJS(exports_src);
-
-// src/types.ts
-function isSingleObjectPush(push) {
-  if (push === null || typeof push !== "object" || Array.isArray(push))
-    return false;
-  const value = push;
-  return typeof value.map === "function" || typeof value.verify === "function";
-}
-var SINGLE_OBJECT_PUSH_MESSAGE = "push must be declared by name, e.g. push: { default: { map } }; the single-object form push: { map } is not supported";
-function defineConnector(definition) {
-  if (definition !== null && typeof definition === "object" && isSingleObjectPush(definition.push)) {
-    throw new TypeError(SINGLE_OBJECT_PUSH_MESSAGE);
-  }
-  return definition;
-}
-// src/t.ts
-var META_KEYS = ["title", "description", "placeholder"];
-function build(base, meta) {
-  const out = { ...base };
-  if (meta) {
-    for (const key of META_KEYS) {
-      if (meta[key] !== undefined)
-        out[key] = meta[key];
-    }
-  }
-  return Object.freeze(out);
-}
-function scalar(kind, meta) {
-  return build({ kind }, meta);
-}
-var t = Object.freeze({
-  string: (meta) => scalar("string", meta),
-  integer: (meta) => scalar("integer", meta),
-  decimal: (precision, scale, meta) => build({ kind: "decimal", precision, scale }, meta),
-  boolean: (meta) => scalar("boolean", meta),
-  date: (meta) => scalar("date", meta),
-  instant: (meta) => scalar("instant", meta),
-  json: (meta) => scalar("json", meta),
-  object: (shape, meta) => build({ kind: "object", shape: Object.freeze({ ...shape }) }, meta),
-  array: (item, meta) => build({ kind: "array", item }, meta),
-  secret: (options) => build(options?.exposeToScript === true ? { kind: "secret", exposeToScript: true } : { kind: "secret" }, options)
-});
-// src/errors.ts
-class ConnectorError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "ConnectorError";
-    this.code = code;
-  }
-}
-
-class AuthError extends ConnectorError {
-  constructor(message) {
-    super("AUTH_ERROR", message);
-    this.name = "AuthError";
-  }
-}
-
-class RateLimited extends ConnectorError {
-  retryAfterMs;
-  constructor(retryAfterMs, message) {
-    super("RATE_LIMITED", message ?? `rate limited, retry after ${retryAfterMs} ms`);
-    this.name = "RateLimited";
-    this.retryAfterMs = retryAfterMs;
-  }
-}
-
-class TransientError extends ConnectorError {
-  constructor(message) {
-    super("TRANSIENT_ERROR", message);
-    this.name = "TransientError";
-  }
-}
-
-class SchemaError extends ConnectorError {
-  constructor(message) {
-    super("SCHEMA_ERROR", message);
-    this.name = "SchemaError";
-  }
-}
-
-class FatalError extends ConnectorError {
-  constructor(message) {
-    super("FATAL_ERROR", message);
-    this.name = "FatalError";
-  }
-}
-
-class RejectedPayload extends ConnectorError {
-  constructor(message) {
-    super("REJECTED_PAYLOAD", message);
-    this.name = "RejectedPayload";
-  }
-}
-
-class NotAvailable extends ConnectorError {
-  constructor(feature) {
-    super("NOT_AVAILABLE", `${feature} is not available yet`);
-    this.name = "NotAvailable";
-  }
-}
-var errors = Object.freeze({ AuthError, RateLimited, TransientError, SchemaError, FatalError, RejectedPayload, NotAvailable });
-// src/validate.ts
-var SDK_NAME_PATTERN = /^[a-z][a-z0-9_]{0,27}$/;
-var RESERVED_PUSH_NAMES = Object.freeze(["dev"]);
-var DEFAULT_PUSH_NAME = "default";
-var VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
-var SCALAR_KINDS = new Set(["string", "integer", "decimal", "boolean", "date", "instant", "json"]);
-var RETENTION_KINDS = new Set(["instant", "date"]);
-var SYNC_MODES = new Set(["full", "incremental"]);
-var SNAPSHOTS = new Set(["complete", "partial"]);
-var PURGE_KEYS = ["tenant", "user"];
-var FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var HOST_PLACEHOLDER = /\{config\.([^{}]*)\}/g;
-var HOST_LABEL = "[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
-var HOST_PATTERN = new RegExp(`^(?:\\*\\.)?${HOST_LABEL}(?:\\.${HOST_LABEL})*$`, "i");
-var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-var INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
-var DECIMAL_TEXT_PATTERN = /^-?\d+(?:\.\d+)?$/;
-var PRESENTATION_LIMITS = Object.freeze({
-  title: 40,
-  description: 120,
-  readmeBytes: 65536,
-  iconBytes: 262144,
-  iconMinPx: 128,
-  fieldTitle: 40,
-  fieldDescription: 200,
-  placeholder: 100,
-  tableTitle: 40,
-  tableDescription: 200
-});
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPositiveInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function validateText(path, owner, key, max, issues) {
-  const value = owner[key];
-  if (value === undefined)
-    return;
-  if (typeof value !== "string") {
-    issues.push({ path: `${path}.${key}`, message: `${key} must be a string` });
-  } else if ([...value].length > max) {
-    issues.push({ path: `${path}.${key}`, message: `${key} must be at most ${max} characters` });
-  }
-}
-function validateFieldMeta(path, type, issues) {
-  validateText(path, type, "title", PRESENTATION_LIMITS.fieldTitle, issues);
-  validateText(path, type, "description", PRESENTATION_LIMITS.fieldDescription, issues);
-  if (type.placeholder !== undefined && (type.kind === "object" || type.kind === "array")) {
-    issues.push({ path: `${path}.placeholder`, message: "placeholder is only allowed on scalar and secret fields" });
-    return;
-  }
-  validateText(path, type, "placeholder", PRESENTATION_LIMITS.placeholder, issues);
-}
-function columnTypeProblem(type) {
-  if (!isRecord(type) || typeof type.kind !== "string" || !SCALAR_KINDS.has(type.kind)) {
-    return "column type must be a scalar type (string, integer, decimal, boolean, date, instant or json)";
-  }
-  if (type.kind === "decimal")
-    return decimalProblem(type);
-  return null;
-}
-function decimalProblem(type) {
-  const { precision, scale } = type;
-  if (!isPositiveInteger(precision) || typeof scale !== "number" || !Number.isInteger(scale) || scale < 0 || scale > precision) {
-    return "decimal needs an integer precision > 0 and an integer scale between 0 and precision";
-  }
-  return null;
-}
-function validateTable(path, table, issues) {
-  if (!isRecord(table)) {
-    issues.push({ path, message: "table declaration must be an object" });
-    return;
-  }
-  const columns = isRecord(table.columns) ? table.columns : null;
-  if (!columns) {
-    issues.push({ path: `${path}.columns`, message: "columns must be an object" });
-    return;
-  }
-  const columnKind = (name) => {
-    const type = columns[name];
-    return isRecord(type) && typeof type.kind === "string" ? type.kind : undefined;
-  };
-  const isDeclared = (name) => typeof name === "string" && Object.hasOwn(columns, name);
-  for (const [name, type] of Object.entries(columns)) {
-    const problem = columnTypeProblem(type);
-    if (problem)
-      issues.push({ path: `${path}.columns.${name}`, message: problem });
-    else
-      validateFieldMeta(`${path}.columns.${name}`, type, issues);
-  }
-  validateText(path, table, "title", PRESENTATION_LIMITS.tableTitle, issues);
-  validateText(path, table, "description", PRESENTATION_LIMITS.tableDescription, issues);
-  const primaryKey = table.primaryKey;
-  if (!isStringArray(primaryKey) || primaryKey.length === 0) {
-    issues.push({ path: `${path}.primaryKey`, message: "primaryKey must be a non-empty list of column names" });
-  } else {
-    const missing = primaryKey.filter((name) => !isDeclared(name));
-    if (missing.length > 0) {
-      issues.push({ path: `${path}.primaryKey`, message: `primaryKey references undeclared columns: ${missing.join(", ")}` });
-    }
-  }
-  if (table.retention !== undefined) {
-    const retention = table.retention;
-    if (!isRecord(retention)) {
-      issues.push({ path: `${path}.retention`, message: "retention must be an object" });
-    } else {
-      const column = retention.column;
-      if (!isDeclared(column)) {
-        issues.push({ path: `${path}.retention.column`, message: "retention column must be a declared column" });
-      } else if (!RETENTION_KINDS.has(columnKind(column) ?? "")) {
-        issues.push({ path: `${path}.retention.column`, message: "retention column must be of type instant or date" });
-      } else if (!isStringArray(primaryKey) || !primaryKey.includes(column)) {
-        issues.push({ path: `${path}.retention.column`, message: "retention column must be part of primaryKey" });
-      }
-      if (!isPositiveInteger(retention.days)) {
-        issues.push({ path: `${path}.retention.days`, message: "retention days must be a positive integer" });
-      }
-    }
-  }
-  if (table.purgeColumns !== undefined) {
-    const purgeColumns = table.purgeColumns;
-    if (!isRecord(purgeColumns)) {
-      issues.push({ path: `${path}.purgeColumns`, message: "purgeColumns must be an object" });
-    } else {
-      for (const key of PURGE_KEYS) {
-        const column = purgeColumns[key];
-        if (column !== undefined && !isDeclared(column)) {
-          issues.push({ path: `${path}.purgeColumns.${key}`, message: "purge column must be a declared column" });
-        }
-      }
-    }
-  }
-  if (table.indexes !== undefined) {
-    const indexes = table.indexes;
-    if (!Array.isArray(indexes)) {
-      issues.push({ path: `${path}.indexes`, message: "indexes must be a list of column lists" });
-    } else {
-      indexes.forEach((index, i) => {
-        if (!isStringArray(index) || index.length === 0 || !index.every(isDeclared)) {
-          issues.push({ path: `${path}.indexes[${i}]`, message: "index must be a non-empty list of declared columns" });
-        }
-      });
-    }
-  }
-}
-function validateTables(path, tables, owners, owner, issues) {
-  if (!isRecord(tables)) {
-    issues.push({ path, message: "tables must be an object" });
-    return;
-  }
-  for (const [name, table] of Object.entries(tables)) {
-    const tablePath = `${path}.${name}`;
-    if (!SDK_NAME_PATTERN.test(name)) {
-      issues.push({ path: tablePath, message: `table name must match ${SDK_NAME_PATTERN.source}` });
-    }
-    const previous = owners.get(name);
-    if (previous !== undefined) {
-      issues.push({ path: tablePath, message: `table ${name} is already declared by ${previous}` });
-    } else {
-      owners.set(name, owner);
-    }
-    validateTable(tablePath, table, issues);
-  }
-}
-function validateSdkType(path, type, rules, issues) {
-  if (!isRecord(type) || typeof type.kind !== "string") {
-    issues.push({ path, message: "type must be declared with t.*()" });
-    return;
-  }
-  const nested = { secretAllowed: false, secretMessage: rules.secretMessage };
-  if (type.kind === "secret" || type.kind === "object" || type.kind === "array" || SCALAR_KINDS.has(type.kind)) {
-    validateFieldMeta(path, type, issues);
-  }
-  switch (type.kind) {
-    case "secret":
-      if (!rules.secretAllowed)
-        issues.push({ path, message: rules.secretMessage });
-      else if (type.exposeToScript !== undefined && typeof type.exposeToScript !== "boolean") {
-        issues.push({ path: `${path}.exposeToScript`, message: "exposeToScript must be a boolean" });
-      }
-      return;
-    case "object":
-      validateShape(path, type, nested, issues);
-      return;
-    case "array":
-      validateSdkType(`${path}[]`, type.item, nested, issues);
-      return;
-    case "decimal": {
-      const problem = decimalProblem(type);
-      if (problem)
-        issues.push({ path, message: problem });
-      return;
-    }
-    default:
-      if (!SCALAR_KINDS.has(type.kind))
-        issues.push({ path, message: `unknown type kind ${type.kind}` });
-  }
-}
-function validateShape(path, type, fieldRules, issues) {
-  if (!isRecord(type.shape)) {
-    issues.push({ path, message: "object type needs a shape" });
-    return;
-  }
-  for (const [field, fieldType] of Object.entries(type.shape)) {
-    const fieldPath = `${path}.${field}`;
-    if (!FIELD_NAME_PATTERN.test(field)) {
-      issues.push({ path: fieldPath, message: `field name must match ${FIELD_NAME_PATTERN.source}` });
-    }
-    validateSdkType(fieldPath, fieldType, fieldRules, issues);
-  }
-}
-function validateObjectDeclaration(path, type, rules, issues) {
-  if (!isRecord(type) || type.kind !== "object") {
-    issues.push({ path, message: `${path} must be declared with t.object()` });
-    return false;
-  }
-  validateFieldMeta(path, type, issues);
-  validateShape(path, type, rules, issues);
-  return true;
-}
-function configFieldType(config, fieldPath) {
-  let current = config;
-  for (const segment of fieldPath.split(".")) {
-    if (!isRecord(current) || current.kind !== "object" || !isRecord(current.shape) || !Object.hasOwn(current.shape, segment))
-      return;
-    current = current.shape[segment];
-  }
-  return isRecord(current) ? current : undefined;
-}
-function pushNames(push) {
-  return isRecord(push) ? Object.keys(push) : [];
-}
-function validatePushHandler(path, handler, issues) {
-  if (!isRecord(handler)) {
-    issues.push({ path, message: "push handler must be an object with map()" });
-    return;
-  }
-  if (handler.verify !== undefined && typeof handler.verify !== "function") {
-    issues.push({ path: `${path}.verify`, message: `${path}.verify must be a function` });
-  }
-  if (typeof handler.map !== "function") {
-    issues.push({ path: `${path}.map`, message: `${path}.map must be a function` });
-  }
-}
-function validatePush(push, issues) {
-  if (push === undefined)
-    return 0;
-  if (!isRecord(push)) {
-    issues.push({ path: "push", message: "push must be an object" });
-    return 0;
-  }
-  if (isSingleObjectPush(push)) {
-    issues.push({ path: "push", message: SINGLE_OBJECT_PUSH_MESSAGE });
-    return 1;
-  }
-  const names = Object.keys(push);
-  if (names.length === 0) {
-    issues.push({ path: "push", message: "push must declare at least one handler, e.g. push: { default: { map } }" });
-    return 0;
-  }
-  for (const name of names) {
-    const path = `push.${name}`;
-    if (!SDK_NAME_PATTERN.test(name)) {
-      issues.push({ path, message: `push name must match ${SDK_NAME_PATTERN.source}` });
-    } else if (RESERVED_PUSH_NAMES.includes(name)) {
-      issues.push({ path, message: `push name ${name} is reserved` });
-    }
-    validatePushHandler(path, push[name], issues);
-  }
-  return names.length;
-}
-function validateHosts(hosts, config, issues) {
-  if (hosts === undefined)
-    return 0;
-  if (!Array.isArray(hosts)) {
-    issues.push({ path: "hosts", message: "hosts must be a list of host names" });
-    return 0;
-  }
-  hosts.forEach((host, i) => {
-    const path = `hosts[${i}]`;
-    if (typeof host !== "string" || host.length === 0 || host.length > 253) {
-      issues.push({ path, message: "host must be a non-empty string" });
-      return;
-    }
-    for (const match of host.matchAll(HOST_PLACEHOLDER)) {
-      const fieldPath = match[1] ?? "";
-      const fieldType = configFieldType(config, fieldPath);
-      if (!fieldType) {
-        issues.push({ path, message: `host template references undeclared config field ${fieldPath}` });
-      } else if (fieldType.kind !== "string") {
-        issues.push({ path, message: `host template field ${fieldPath} must be declared with t.string()` });
-      }
-    }
-    if (!HOST_PATTERN.test(host.replace(HOST_PLACEHOLDER, "x"))) {
-      issues.push({ path, message: "host must be an exact host name or *.suffix, without scheme, port or path" });
-    }
-  });
-  return hosts.length;
-}
-function validateRateLimit(rateLimit, issues) {
-  if (rateLimit === undefined)
-    return;
-  if (!isRecord(rateLimit)) {
-    issues.push({ path: "rateLimit", message: "rateLimit must be { perSecond, concurrency }" });
-    return;
-  }
-  const { perSecond, concurrency } = rateLimit;
-  if (typeof perSecond !== "number" || !Number.isFinite(perSecond) || perSecond <= 0) {
-    issues.push({ path: "rateLimit.perSecond", message: "rateLimit.perSecond must be a positive number" });
-  }
-  if (!isPositiveInteger(concurrency)) {
-    issues.push({ path: "rateLimit.concurrency", message: "rateLimit.concurrency must be a positive integer" });
-  }
-}
-function validateStreams(streams, issues) {
-  if (streams === undefined)
-    return 0;
-  if (!isRecord(streams)) {
-    issues.push({ path: "streams", message: "streams must be an object of async generator functions" });
-    return 0;
-  }
-  for (const [name, stream] of Object.entries(streams)) {
-    const path = `streams.${name}`;
-    if (!SDK_NAME_PATTERN.test(name))
-      issues.push({ path, message: `stream name must match ${SDK_NAME_PATTERN.source}` });
-    if (typeof stream !== "function")
-      issues.push({ path, message: `${path} must be an async generator function` });
-  }
-  return Object.keys(streams).length;
-}
-function validateConnectorDefinition(definition) {
-  if (!isRecord(definition)) {
-    return [{ path: "", message: "connector definition must be an object" }];
-  }
-  const issues = [];
-  if (typeof definition.name !== "string" || !SDK_NAME_PATTERN.test(definition.name)) {
-    issues.push({ path: "name", message: `name must match ${SDK_NAME_PATTERN.source}` });
-  }
-  if (typeof definition.version !== "string" || !VERSION_PATTERN.test(definition.version)) {
-    issues.push({ path: "version", message: "version must be a semver string like 1.0.0" });
-  }
-  validateObjectDeclaration("config", definition.config, {
-    secretAllowed: true,
-    secretMessage: "secret fields must be top-level config fields"
-  }, issues);
-  const hostCount = validateHosts(definition.hosts, definition.config, issues);
-  const hasDb = definition.db !== undefined;
-  if (hasDb && (!isRecord(definition.db) || definition.db.engine !== "postgresql")) {
-    issues.push({ path: "db.engine", message: "db.engine must be 'postgresql'" });
-  }
-  validateRateLimit(definition.rateLimit, issues);
-  if (definition.check !== undefined && typeof definition.check !== "function") {
-    issues.push({ path: "check", message: "check must be a function" });
-  }
-  if (typeof definition.discover !== "function") {
-    issues.push({ path: "discover", message: "discover must be a function" });
-  }
-  if (definition.writes !== undefined) {
-    issues.push({ path: "writes", message: "external write operations are not available yet" });
-  }
-  const streamCount = validateStreams(definition.streams, issues);
-  const pushCount = validatePush(definition.push, issues);
-  if (streamCount === 0 && pushCount === 0) {
-    issues.push({ path: "streams", message: "connector must declare at least one stream or push" });
-  }
-  if (streamCount > 0 && hostCount === 0 && !hasDb) {
-    issues.push({ path: "hosts", message: "connectors with streams must declare hosts (for ctx.http) or db (for ctx.db)" });
-  }
-  return issues;
-}
-function validateStreamDiscovery(path, stream, owners, issues) {
-  if (!isRecord(stream)) {
-    issues.push({ path, message: "stream declaration must be an object" });
-    return;
-  }
-  validateTables(`${path}.tables`, stream.tables, owners, path, issues);
-  const syncModes = stream.syncModes;
-  if (!isStringArray(syncModes) || syncModes.length === 0 || !syncModes.every((mode) => SYNC_MODES.has(mode)) || new Set(syncModes).size !== syncModes.length) {
-    issues.push({ path: `${path}.syncModes`, message: "syncModes must be a non-empty list of 'full' and/or 'incremental'" });
-  }
-  if (stream.snapshot !== undefined && (typeof stream.snapshot !== "string" || !SNAPSHOTS.has(stream.snapshot))) {
-    issues.push({ path: `${path}.snapshot`, message: "snapshot must be 'complete' or 'partial'" });
-  }
-  if (stream.params !== undefined) {
-    validateObjectDeclaration(`${path}.params`, stream.params, {
-      secretAllowed: false,
-      secretMessage: "stream params cannot contain secret fields"
-    }, issues);
-  }
-}
-function definitionStreamNames(definition) {
-  if (!isRecord(definition) || !isRecord(definition.streams))
-    return [];
-  return Object.keys(definition.streams);
-}
-function definitionPushNames(definition) {
-  if (!isRecord(definition))
-    return [];
-  return pushNames(definition.push);
-}
-function validateDiscoverResult(result, definition) {
-  if (!isRecord(result)) {
-    return [{ path: "", message: "discover result must be an object" }];
-  }
-  const issues = [];
-  const owners = new Map;
-  const declaredStreams = definitionStreamNames(definition);
-  const streams = result.streams === undefined ? {} : result.streams;
-  if (!isRecord(streams)) {
-    issues.push({ path: "streams", message: "streams must be an object" });
-  } else {
-    for (const [name, stream] of Object.entries(streams)) {
-      const path = `streams.${name}`;
-      if (!declaredStreams.includes(name)) {
-        issues.push({ path, message: `stream ${name} is not defined in the connector's streams` });
-      }
-      validateStreamDiscovery(path, stream, owners, issues);
-    }
-    for (const name of declaredStreams) {
-      if (!Object.hasOwn(streams, name)) {
-        issues.push({ path: `streams.${name}`, message: `stream ${name} is defined but missing from the discover result` });
-      }
-    }
-  }
-  const declaredPushes = definitionPushNames(definition);
-  const pushes = result.push === undefined ? {} : result.push;
-  if (!isRecord(pushes)) {
-    issues.push({ path: "push", message: "push must be an object of { tables } by push name" });
-  } else {
-    for (const [name, push] of Object.entries(pushes)) {
-      const path = `push.${name}`;
-      if (!declaredPushes.includes(name)) {
-        issues.push({ path, message: `push ${name} is not defined in the connector's push handlers` });
-      }
-      if (!isRecord(push)) {
-        issues.push({ path, message: "push declaration must be { tables }" });
-        continue;
-      }
-      validateTables(`${path}.tables`, push.tables, owners, path, issues);
-    }
-    for (const name of declaredPushes) {
-      if (!Object.hasOwn(pushes, name)) {
-        issues.push({ path: `push.${name}`, message: `push ${name} is defined but missing from the discover result` });
-      }
-    }
-  }
-  return issues;
-}
-function normalizeDiscoverResult(result) {
-  const streams = {};
-  for (const [name, stream] of Object.entries(result.streams ?? {})) {
-    streams[name] = {
-      tables: stream.tables,
-      syncModes: [...stream.syncModes],
-      snapshot: stream.snapshot ?? "partial",
-      ...stream.params ? { params: stream.params } : {}
-    };
-  }
-  const pushes = {};
-  for (const [name, push] of Object.entries(result.push ?? {}))
-    pushes[name] = { tables: push.tables };
-  return { streams, pushes };
-}
-function topLevelSecrets(config) {
-  if (!isRecord(config) || !isRecord(config.shape))
-    return [];
-  const secrets = [];
-  for (const [field, type] of Object.entries(config.shape)) {
-    if (isRecord(type) && type.kind === "secret")
-      secrets.push({ field, exposeToScript: type.exposeToScript === true });
-  }
-  return secrets;
-}
-function summarizeDefinition(definition) {
-  const secrets = topLevelSecrets(definition.config);
-  const rateLimit = definition.rateLimit;
-  return {
-    name: definition.name,
-    version: definition.version,
-    hosts: Array.isArray(definition.hosts) ? definition.hosts.filter((host) => typeof host === "string") : [],
-    db: definition.db?.engine === "postgresql" ? { engine: "postgresql" } : null,
-    rateLimit: rateLimit ? { perSecond: rateLimit.perSecond, concurrency: rateLimit.concurrency } : null,
-    pushes: pushNames(definition.push),
-    streams: definitionStreamNames(definition),
-    secretFields: secrets.map((secret) => secret.field),
-    exposeToScript: secrets.filter((secret) => secret.exposeToScript).map((secret) => secret.field),
-    ...isRecord(definition.config) ? { config: JSON.parse(JSON.stringify(definition.config)) } : {}
-  };
-}
-function isValidDate(text) {
-  if (!DATE_PATTERN.test(text))
-    return false;
-  const date = new Date(`${text}T00:00:00Z`);
-  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === text;
-}
-function validateValue(path, type, value, issues) {
-  if (!isRecord(type) || typeof type.kind !== "string") {
-    issues.push({ path, message: "field type is not a valid t.*() declaration" });
-    return;
-  }
-  const fail = (expected) => issues.push({ path, message: `${path} must be ${expected}` });
-  switch (type.kind) {
-    case "string":
-      if (typeof value !== "string")
-        fail("a string");
-      return;
-    case "integer":
-      if (typeof value !== "number" || !Number.isSafeInteger(value))
-        fail("an integer");
-      return;
-    case "decimal":
-      if (!(typeof value === "number" && Number.isFinite(value)) && !(typeof value === "string" && DECIMAL_TEXT_PATTERN.test(value)))
-        fail("a decimal number");
-      return;
-    case "boolean":
-      if (typeof value !== "boolean")
-        fail("a boolean");
-      return;
-    case "date":
-      if (typeof value !== "string" || !isValidDate(value))
-        fail("a date like 2026-01-31");
-      return;
-    case "instant":
-      if (typeof value !== "string" || !INSTANT_PATTERN.test(value) || Number.isNaN(Date.parse(value)))
-        fail("an ISO 8601 timestamp with time zone");
-      return;
-    case "json":
-      return;
-    case "object":
-      if (!isRecord(value)) {
-        fail("an object");
-        return;
-      }
-      validateFields(path, type, value, issues, false);
-      return;
-    case "array":
-      if (!Array.isArray(value)) {
-        fail("an array");
-        return;
-      }
-      value.forEach((item, i) => {
-        if (item === undefined || item === null)
-          issues.push({ path: `${path}[${i}]`, message: `${path}[${i}] is required` });
-        else
-          validateValue(`${path}[${i}]`, type.item, item, issues);
-      });
-      return;
-    case "secret":
-      issues.push({ path, message: "secret fields must be top-level config fields" });
-      return;
-    default:
-      issues.push({ path, message: `unknown type kind ${type.kind}` });
-  }
-}
-function validateFields(path, type, value, issues, topLevel) {
-  const shape = isRecord(type.shape) ? type.shape : {};
-  for (const [field, fieldType] of Object.entries(shape)) {
-    const fieldPath = `${path}.${field}`;
-    if (topLevel && isRecord(fieldType) && fieldType.kind === "secret")
-      continue;
-    const fieldValue = value[field];
-    if (fieldValue === undefined || fieldValue === null) {
-      if (!(isRecord(fieldType) && fieldType.kind === "json" && fieldValue === null)) {
-        issues.push({ path: fieldPath, message: `${fieldPath} is required` });
-      }
-      continue;
-    }
-    validateValue(fieldPath, fieldType, fieldValue, issues);
-  }
-  for (const field of Object.keys(value)) {
-    if (!Object.hasOwn(shape, field))
-      issues.push({ path: `${path}.${field}`, message: `${path}.${field} is not declared` });
-  }
-}
-function validateConfig(schema, config) {
-  if (!isRecord(config))
-    return [{ path: "config", message: "config must be an object" }];
-  const issues = [];
-  validateFields("config", schema, config, issues, true);
-  return issues;
-}
-// src/presentation.ts
-var PACKAGE_JSON = "package.json";
-var README = "README.md";
-var ICON_PATHS = ["icon.svg", "icon.png"];
-var ICON_MIME = { "icon.svg": "image/svg+xml", "icon.png": "image/png" };
-var PNG_DATA_URI_PREFIX = "data:image/png;base64,";
-var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
-var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
-var FORBIDDEN_SVG_ELEMENTS = new Set(["script", "foreignobject", "iframe", "object", "embed"]);
-var ALLOWED_ENTITIES = new Set(["amp", "lt", "gt", "quot", "apos"]);
-var EMPTY_PRESENTATION = { title: null, description: null, icon: null, readme: false };
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function charCount(text) {
-  return [...text].length;
-}
-function utf8Length(text) {
-  return new TextEncoder().encode(text).length;
-}
-function readText(owner, key, path, max, issues) {
-  const value = owner[key];
-  if (value === undefined)
-    return null;
-  if (typeof value !== "string" || value.trim().length === 0) {
-    issues.push({ path, message: `${path.slice(PACKAGE_JSON.length + 1)} must be a non-empty string` });
-    return null;
-  }
-  if (charCount(value) > max) {
-    issues.push({ path, message: `${path.slice(PACKAGE_JSON.length + 1)} must be at most ${max} characters` });
-    return null;
-  }
-  return value;
-}
-function scanSvgTags(text) {
-  const tags = [];
-  let i = 0;
-  const n = text.length;
-  const isSpace = (ch) => ch === " " || ch === "\t" || ch === `
-` || ch === "\r";
-  while (i < n) {
-    const lt = text.indexOf("<", i);
-    if (lt === -1)
-      break;
-    if (text.startsWith("<!--", lt)) {
-      const end = text.indexOf("-->", lt + 4);
-      if (end === -1)
-        return null;
-      i = end + 3;
-      continue;
-    }
-    if (text.startsWith("<?", lt)) {
-      const end = text.indexOf("?>", lt + 2);
-      if (end === -1)
-        return null;
-      i = end + 2;
-      continue;
-    }
-    i = lt + 1;
-    if (text[i] === "/") {
-      const end = text.indexOf(">", i);
-      if (end === -1)
-        return null;
-      i = end + 1;
-      continue;
-    }
-    while (isSpace(text[i]))
-      i += 1;
-    let name = "";
-    while (i < n && !isSpace(text[i]) && text[i] !== ">" && text[i] !== "/")
-      name += text[i++];
-    const tag = { name: name.slice(name.lastIndexOf(":") + 1), attributes: [] };
-    for (;; ) {
-      while (isSpace(text[i]))
-        i += 1;
-      if (i >= n)
-        return null;
-      if (text[i] === ">") {
-        i += 1;
-        break;
-      }
-      if (text[i] === "/") {
-        i += 1;
-        continue;
-      }
-      let attr = "";
-      while (i < n && !isSpace(text[i]) && text[i] !== "=" && text[i] !== ">" && text[i] !== "/")
-        attr += text[i++];
-      while (isSpace(text[i]))
-        i += 1;
-      let value = "";
-      if (text[i] === "=") {
-        i += 1;
-        while (isSpace(text[i]))
-          i += 1;
-        const quote = text[i];
-        if (quote === '"' || quote === "'") {
-          const end = text.indexOf(quote, i + 1);
-          if (end === -1)
-            return null;
-          value = text.slice(i + 1, end);
-          i = end + 1;
-        } else {
-          while (i < n && !isSpace(text[i]) && text[i] !== ">")
-            value += text[i++];
-        }
-      }
-      if (attr)
-        tag.attributes.push({ name: attr, value });
-    }
-    tags.push(tag);
-  }
-  return tags;
-}
-function cssProblem(css) {
-  const lower = css.toLowerCase();
-  if (lower.includes("url(") || lower.includes("@import"))
-    return "must not reference url() or @import in styles";
-  if (css.includes("\\"))
-    return "must not use escapes in styles";
-  return null;
-}
-function svgIconProblem(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("<!doctype") || lower.includes("<!entity"))
-    return "icon.svg must not contain <!DOCTYPE> or <!ENTITY>";
-  if (lower.includes("<![cdata["))
-    return "icon.svg must not contain CDATA sections";
-  for (const match of lower.matchAll(/&(#?[a-z0-9]*);?/g)) {
-    if (!ALLOWED_ENTITIES.has(match[1] ?? "") || !match[0].endsWith(";"))
-      return "icon.svg must not contain character or entity references other than &amp; &lt; &gt; &quot; &apos;";
-  }
-  const tags = scanSvgTags(lower);
-  if (tags === null)
-    return "icon.svg is not well-formed XML";
-  const root = tags[0];
-  if (!root || root.name !== "svg")
-    return "icon.svg must have an <svg> root element";
-  if (!root.attributes.some((attribute) => attribute.name === "viewbox"))
-    return "icon.svg root element must have a viewBox";
-  for (const tag of tags) {
-    if (FORBIDDEN_SVG_ELEMENTS.has(tag.name))
-      return `icon.svg must not contain <${tag.name}>`;
-    for (const { name, value } of tag.attributes) {
-      const local = name.slice(name.lastIndexOf(":") + 1);
-      if (local.startsWith("on"))
-        return `icon.svg must not contain event handler attributes (${name})`;
-      if (local === "href" && !value.trim().startsWith("#"))
-        return `icon.svg ${name} must be a local reference starting with #`;
-      if (local === "style") {
-        const problem = cssProblem(value);
-        if (problem)
-          return `icon.svg style attribute ${problem}`;
-      }
-    }
-  }
-  for (const match of lower.matchAll(/<(?:[a-z0-9_.-]+:)?style\b[^>]*>([\s\S]*?)(?:<\/|$)/g)) {
-    const problem = cssProblem(match[1] ?? "");
-    if (problem)
-      return `icon.svg <style> ${problem}`;
-  }
-  return null;
-}
-function decodeBase64(text) {
-  if (text.length % 4 !== 0 || !BASE64.test(text))
-    return null;
-  try {
-    const binary = atob(text);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0;i < binary.length; i += 1)
-      bytes[i] = binary.charCodeAt(i);
-    return bytes;
-  } catch {
-    return null;
-  }
-}
-function readUint32(bytes, offset) {
-  return (bytes[offset] ?? 0) * 16777216 + ((bytes[offset + 1] ?? 0) << 16 | (bytes[offset + 2] ?? 0) << 8 | (bytes[offset + 3] ?? 0));
-}
-function checkIcon(path, content) {
-  const limit = PRESENTATION_LIMITS.iconBytes;
-  if (path === "icon.svg") {
-    const bytes = new TextEncoder().encode(content);
-    if (bytes.length > limit)
-      return { problem: `icon.svg must be at most ${limit} bytes` };
-    const problem = svgIconProblem(content);
-    return problem ? { problem } : { bytes };
-  }
-  if (!content.startsWith(PNG_DATA_URI_PREFIX))
-    return { problem: `icon.png must be stored as ${PNG_DATA_URI_PREFIX}<data>` };
-  const encoded = content.slice(PNG_DATA_URI_PREFIX.length);
-  if (Math.floor(encoded.length / 4) * 3 - 2 > limit)
-    return { problem: `icon.png must be at most ${limit} bytes` };
-  const bytes = decodeBase64(encoded);
-  if (bytes === null)
-    return { problem: "icon.png is not valid base64" };
-  if (bytes.length > limit)
-    return { problem: `icon.png must be at most ${limit} bytes` };
-  if (bytes.length < 24 || PNG_SIGNATURE.some((byte, i) => bytes[i] !== byte) || String.fromCharCode(...bytes.subarray(12, 16)) !== "IHDR") {
-    return { problem: "icon.png is not a PNG image" };
-  }
-  const width = readUint32(bytes, 16);
-  const height = readUint32(bytes, 20);
-  const min = PRESENTATION_LIMITS.iconMinPx;
-  if (width !== height || width < min)
-    return { problem: `icon.png must be square and at least ${min}×${min} pixels, got ${width}×${height}` };
-  return { bytes };
-}
-function readConnectorPresentation(files, sha256) {
-  const issues = [];
-  let pkg;
-  try {
-    pkg = JSON.parse(files[PACKAGE_JSON] ?? "");
-  } catch {
-    pkg = undefined;
-  }
-  if (!isRecord2(pkg)) {
-    return { presentation: { ...EMPTY_PRESENTATION }, issues: [{ path: PACKAGE_JSON, message: "package.json must be a JSON object" }] };
-  }
-  const presentation = { ...EMPTY_PRESENTATION };
-  presentation.description = readText(pkg, "description", `${PACKAGE_JSON}:description`, PRESENTATION_LIMITS.description, issues);
-  const ontos = pkg.ontos;
-  if (ontos !== undefined && !isRecord2(ontos)) {
-    issues.push({ path: `${PACKAGE_JSON}:ontos`, message: "ontos must be an object" });
-  } else if (ontos) {
-    presentation.title = readText(ontos, "title", `${PACKAGE_JSON}:ontos.title`, PRESENTATION_LIMITS.title, issues);
-    const icon = ontos.icon;
-    if (icon !== undefined) {
-      if (typeof icon !== "string" || !ICON_PATHS.includes(icon)) {
-        issues.push({ path: `${PACKAGE_JSON}:ontos.icon`, message: "ontos.icon must be icon.svg or icon.png (a file in the source root)" });
-      } else {
-        const path = icon;
-        const content = files[path];
-        if (content === undefined) {
-          issues.push({ path, message: `${path} is referenced by ontos.icon but missing` });
-        } else {
-          const checked = checkIcon(path, content);
-          if ("problem" in checked)
-            issues.push({ path, message: checked.problem });
-          else
-            presentation.icon = { path, mime: ICON_MIME[path], sha256: sha256(checked.bytes), bytes: checked.bytes.length };
-        }
-      }
-    }
-  }
-  const readme = files[README];
-  if (readme !== undefined) {
-    if (utf8Length(readme) > PRESENTATION_LIMITS.readmeBytes) {
-      issues.push({ path: README, message: `README.md must be at most ${PRESENTATION_LIMITS.readmeBytes} bytes` });
-    } else {
-      presentation.readme = true;
-    }
-  }
-  return { presentation, issues };
-}
-function decodeConnectorIcon(files, path) {
-  const content = files[path];
-  if (content === undefined || !ICON_PATHS.includes(path))
-    return null;
-  const checked = checkIcon(path, content);
-  return "bytes" in checked ? checked.bytes : null;
-}
-
-// src/index.ts
-var SDK_VERSION = "3.0.1";
-var SUPPORTED_SDK_MAJORS = [3];