@contractspec/lib.contracts 1.61.0 → 1.63.0

package/dist/node/integrations/openbanking/contracts/accounts.js

@@ -1,974 +0,0 @@
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/registry-utils.ts
-var exports_registry_utils = {};
-__export(exports_registry_utils, {
-  groupByToArray: () => groupByToArray,
-  groupByMultiple: () => groupByMultiple,
-  groupBy: () => groupBy,
-  getUniqueTags: () => getUniqueTags,
-  getUniqueOwners: () => getUniqueOwners,
-  getUniqueDomains: () => getUniqueDomains,
-  filterBy: () => filterBy,
-  GroupingStrategies: () => GroupingStrategies
-});
-function filterBy(items, filter) {
-  return items.filter((item) => {
-    if (filter.tags?.length) {
-      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
-      if (!hasMatchingTag)
-        return false;
-    }
-    if (filter.owners?.length) {
-      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
-      if (!hasMatchingOwner)
-        return false;
-    }
-    if (filter.stability?.length) {
-      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
-        return false;
-      }
-    }
-    if (filter.domain) {
-      const itemDomain = GroupingStrategies.byDomain(item);
-      if (itemDomain !== filter.domain)
-        return false;
-    }
-    if (filter.keyPattern) {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      if (!regex.test(name))
-        return false;
-    }
-    return true;
-  });
-}
-function groupBy(items, keyFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const key = keyFn(item);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      groups.set(key, [item]);
-    }
-  }
-  return groups;
-}
-function groupByToArray(items, keyFn) {
-  const map = groupBy(items, keyFn);
-  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
-}
-function groupByMultiple(items, keysFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const keys = keysFn(item);
-    for (const key of keys) {
-      const existing = groups.get(key);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(key, [item]);
-      }
-    }
-  }
-  return groups;
-}
-function getUniqueTags(items) {
-  const tags = new Set;
-  for (const item of items) {
-    for (const tag of item.meta.tags ?? []) {
-      tags.add(tag);
-    }
-  }
-  return Array.from(tags).sort();
-}
-function getUniqueOwners(items) {
-  const owners = new Set;
-  for (const item of items) {
-    for (const owner of item.meta.owners ?? []) {
-      owners.add(owner);
-    }
-  }
-  return Array.from(owners).sort();
-}
-function getUniqueDomains(items) {
-  const domains = new Set;
-  for (const item of items) {
-    domains.add(GroupingStrategies.byDomain(item));
-  }
-  return Array.from(domains).sort();
-}
-var GroupingStrategies;
-var init_registry_utils = __esm(() => {
-  GroupingStrategies = {
-    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
-    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
-    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
-    byDomain: (item) => {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      return name.split(".")[0] ?? "default";
-    },
-    byStability: (item) => item.meta.stability ?? "stable",
-    byUrlPath: (level) => (item) => {
-      if (!item.path)
-        return "root";
-      const segments = item.path.split("/").filter(Boolean);
-      return segments.slice(0, level).join("/") || "root";
-    }
-  };
-});
-
-// src/ownership.ts
-var StabilityEnum = {
-  Idea: "idea",
-  InCreation: "in_creation",
-  Experimental: "experimental",
-  Beta: "beta",
-  Stable: "stable",
-  Deprecated: "deprecated"
-};
-var OwnersEnum = {
-  PlatformCore: "platform.core",
-  PlatformSigil: "platform.sigil",
-  PlatformMarketplace: "platform.marketplace",
-  PlatformMessaging: "platform.messaging",
-  PlatformContent: "platform.content",
-  PlatformFeatureFlags: "platform.featureflags",
-  PlatformFinance: "platform.finance"
-};
-var Owners = OwnersEnum;
-var TagsEnum = {
-  Spots: "spots",
-  Collectivity: "collectivity",
-  Marketplace: "marketplace",
-  Sellers: "sellers",
-  Auth: "auth",
-  Login: "login",
-  Signup: "signup",
-  Guide: "guide",
-  Docs: "docs",
-  I18n: "i18n",
-  Incident: "incident",
-  Automation: "automation",
-  Hygiene: "hygiene"
-};
-var Tags = TagsEnum;
-
-// src/operations/operation.ts
-var isEmitDeclRef = (e) => ("ref" in e);
-var defineCommand = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "command" },
-  policy: {
-    ...spec.policy,
-    idempotent: spec.policy?.["policy"]?.idempotent ?? false
-  }
-});
-var defineQuery = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "query" },
-  policy: { ...spec.policy, idempotent: true }
-});
-
-// src/registry.ts
-init_registry_utils();
-import { compareVersions } from "compare-versions";
-var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
-
-class SpecContractRegistry {
-  contractType;
-  items = new Map;
-  constructor(contractType, items) {
-    this.contractType = contractType;
-    if (items) {
-      items.forEach((p) => this.register(p));
-    }
-  }
-  register(p) {
-    const key = keyOfSpecContract(p);
-    if (this.items.has(key))
-      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
-    this.items.set(key, p);
-    return this;
-  }
-  count() {
-    return this.items.size;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, p] of this.items.entries()) {
-      if (!k.startsWith(`${key}.v`))
-        continue;
-      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
-        candidate = p;
-      }
-    }
-    return candidate;
-  }
-  has(key, version) {
-    return !!this.get(key, version);
-  }
-  filter(criteria) {
-    return filterBy(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((p) => p.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((p) => p.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    return groupBy(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    return getUniqueTags(this.list());
-  }
-}
-
-// src/events.ts
-function defineEvent(e) {
-  return e;
-}
-var eventKey = (key, version) => `${key}.v${version}`;
-
-class EventRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("event", items);
-  }
-}
-
-// src/operations/registry.ts
-function opKey(key, version) {
-  return `${key}.v${version}`;
-}
-
-class OperationSpecRegistry extends SpecContractRegistry {
-  handlers = new Map;
-  constructor(items) {
-    super("operation", items);
-  }
-  bind(spec, handler) {
-    const key = opKey(spec.meta.key, spec.meta.version);
-    if (!this.items.has(key))
-      throw new Error(`Cannot bind; spec not found: ${key}`);
-    if (this.handlers.has(key))
-      throw new Error(`Handler already bound for ${key}`);
-    this.handlers.set(key, handler);
-    return this;
-  }
-  getHandler(key, version) {
-    const spec = this.get(key, version);
-    if (!spec)
-      return;
-    return this.handlers.get(opKey(spec.meta.key, spec.meta.version));
-  }
-  listBound() {
-    const out = [];
-    for (const [k, spec] of this.items.entries()) {
-      const h = this.handlers.get(k);
-      if (h)
-        out.push({ spec, handler: h });
-    }
-    return out;
-  }
-  async execute(key, version, rawInput, ctx) {
-    const baseSpec = this.get(key, version);
-    if (!baseSpec)
-      throw new Error(`Spec not found for ${key}${version ? `.v${version}` : ""}`);
-    const spec = await ctx.specVariantResolver?.resolve({
-      name: baseSpec.meta.key,
-      version: baseSpec.meta.version,
-      kind: baseSpec.meta.kind
-    }, ctx) ?? baseSpec;
-    let handlerKey = opKey(spec.meta.key, spec.meta.version);
-    let handler = this.handlers.get(handlerKey);
-    if (!handler) {
-      const fallbackKey = opKey(baseSpec.meta.key, baseSpec.meta.version);
-      handler = this.handlers.get(fallbackKey);
-      handlerKey = fallbackKey;
-    }
-    if (!handler)
-      throw new Error(`No handler bound for ${handlerKey}`);
-    const parsedInput = spec.io.input?.getZod().parse(rawInput);
-    if (ctx.decide) {
-      const [service, command] = spec.meta.key.split(".");
-      if (!service || !command)
-        throw new Error(`Invalid spec name: ${spec.meta.key}`);
-      const decision = await ctx.decide({
-        service,
-        command,
-        version: spec.meta.version,
-        actor: ctx.actor ?? "anonymous",
-        channel: ctx.channel,
-        roles: ctx.roles,
-        organizationId: ctx.organizationId,
-        userId: ctx.userId,
-        flags: []
-      });
-      if (decision.effect === "deny") {
-        throw new Error(`PolicyDenied: ${spec.meta.key}.v${spec.meta.version}`);
-      }
-      if (decision.rateLimit && ctx.rateLimit) {
-        const key2 = decision.rateLimit.key ?? "default";
-        const rpm = decision.rateLimit.rpm ?? 60;
-        await ctx.rateLimit(key2, 1, rpm);
-      }
-    }
-    const allowedEvents = new Map;
-    if (spec.sideEffects?.emits) {
-      for (const e of spec.sideEffects.emits) {
-        if (isEmitDeclRef(e)) {
-          const eventSpec = ctx.eventSpecResolver?.get(e.ref.key, e.ref.version);
-          if (eventSpec) {
-            allowedEvents.set(`${e.ref.key}.v${e.ref.version}`, eventSpec.payload);
-          }
-        } else {
-          allowedEvents.set(`${e.key}.v${e.version}`, e.payload);
-        }
-      }
-    }
-    const emitGuard = async (eventName, eventVersion, payload) => {
-      const key2 = eventKey(eventName, eventVersion);
-      const schema = allowedEvents.get(key2);
-      if (!schema)
-        throw new Error(`UndeclaredEvent: ${key2} not allowed by ${opKey(spec.meta.key, spec.meta.version)}`);
-      const parsed = schema.getZod().parse(payload);
-      await ctx.eventPublisher?.({
-        key: eventName,
-        version: eventVersion,
-        payload: parsed,
-        traceId: ctx.traceId
-      });
-    };
-    if (ctx.appConfig) {
-      if (!ctx.branding) {
-        ctx.branding = ctx.appConfig.branding;
-      }
-      if (!ctx.translation) {
-        ctx.translation = { config: ctx.appConfig.translation };
-      } else if (!ctx.translation.config) {
-        ctx.translation = {
-          ...ctx.translation,
-          config: ctx.appConfig.translation
-        };
-      }
-    }
-    const telemetryContext = ctx.telemetry;
-    const trackTelemetry = async (trigger, details) => {
-      if (!telemetryContext || !trigger?.event)
-        return;
-      try {
-        const props = trigger.properties?.(details) ?? {};
-        await telemetryContext.track(trigger.event.key, trigger.event.version ?? "1.0.0", props, {
-          tenantId: ctx.organizationId ?? undefined,
-          organizationId: ctx.organizationId,
-          userId: ctx.userId,
-          actor: ctx.actor,
-          channel: ctx.channel,
-          metadata: ctx.traceId ? { traceId: ctx.traceId } : undefined
-        });
-      } catch (_error) {}
-    };
-    let result;
-    try {
-      result = await handler(parsedInput, {
-        ...ctx,
-        __emitGuard__: emitGuard
-      });
-    } catch (error) {
-      if (spec.telemetry?.failure) {
-        await trackTelemetry(spec.telemetry.failure, {
-          input: parsedInput ?? rawInput,
-          error
-        });
-      }
-      throw error;
-    }
-    if (spec.telemetry?.success) {
-      await trackTelemetry(spec.telemetry.success, {
-        input: parsedInput ?? rawInput,
-        output: result
-      });
-    }
-    const outputModel = spec.io.output;
-    if (outputModel?.getZod) {
-      const parsedOutput = outputModel.getZod().parse(result);
-      return parsedOutput;
-    }
-    return result;
-  }
-}
-
-// src/operations/report/getContractVerificationStatus.ts
-import {
-  ScalarTypeEnum,
-  SchemaModel,
-  ZodSchemaType
-} from "@contractspec/lib.schema";
-import * as z from "zod";
-var REPORT_DOMAIN = "report";
-var REPORT_OWNERS = ["platform.core"];
-var REPORT_TAGS = ["report", "drift", "verification"];
-var REPORT_STABILITY = StabilityEnum.Experimental;
-var ContractVerificationStatusModel = new SchemaModel({
-  name: "ContractVerificationStatus",
-  fields: {
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    lastVerifiedSha: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    lastVerifiedDate: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    surfaces: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-      isArray: true
-    },
-    driftMismatches: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    }
-  }
-});
-var GetContractVerificationStatusInput = new SchemaModel({
-  name: "GetContractVerificationStatusInput",
-  fields: {
-    projectPath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    baseline: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var GetContractVerificationStatusOutput = new ZodSchemaType(z.object({
-  contracts: z.object({
-    name: z.string(),
-    lastVerifiedSha: z.string().optional(),
-    lastVerifiedDate: z.string().optional(),
-    surfaces: z.string().array(),
-    driftMismatches: z.int()
-  }).array()
-}), {
-  name: "GetContractVerificationStatusOutput"
-});
-var GetContractVerificationStatusQuery = defineQuery({
-  meta: {
-    key: "report.getContractVerificationStatus",
-    title: "Get Contract Verification Status",
-    version: "1.0.0",
-    description: "Retrieves per-contract verification status for the impact report.",
-    goal: "Enable stakeholders to see contract health at a glance.",
-    context: "Part of the impact report domain. Reads from drift check outputs and verified.json to provide a consolidated view of each contract's drift debt and surface coverage.",
-    domain: REPORT_DOMAIN,
-    owners: REPORT_OWNERS,
-    tags: REPORT_TAGS,
-    stability: REPORT_STABILITY
-  },
-  io: {
-    input: GetContractVerificationStatusInput,
-    output: GetContractVerificationStatusOutput,
-    errors: {
-      PROJECT_NOT_FOUND: {
-        description: "Project path does not exist.",
-        http: 404,
-        when: "The provided projectPath does not resolve to a valid directory."
-      }
-    }
-  },
-  policy: {
-    auth: "anonymous",
-    pii: []
-  }
-});
-
-// src/install.ts
-function makeEmit(_spec, ctx) {
-  return {
-    ref: async (ev, payload) => {
-      await ctx.__emitGuard__?.(ev.meta.key, ev.meta.version, payload);
-    },
-    key: async (key, version, payload) => {
-      await ctx.__emitGuard__?.(key, version, payload);
-    },
-    object: async (evt) => {
-      await ctx.__emitGuard__?.(evt.key, evt.version, evt.payload);
-    }
-  };
-}
-function installOp(reg, spec, handler) {
-  return reg.register(spec).bind(spec, handler);
-}
-function op(spec, handler) {
-  return {
-    spec,
-    handler,
-    install: (reg) => installOp(reg, spec, handler)
-  };
-}
-
-// src/data-views/spec.ts
-function defineDataView(spec) {
-  return spec;
-}
-
-// src/data-views/report/contractVerificationTable.ts
-var ContractVerificationTableDataView = defineDataView({
-  meta: {
-    key: "report.contractVerificationTable",
-    title: "Contract Verification Table",
-    version: "1.0.0",
-    description: "Table view of per-contract verification status for the impact report.",
-    domain: "report",
-    owners: ["platform.core"],
-    tags: ["report", "data-view", "verification"],
-    stability: StabilityEnum.Experimental,
-    entity: "contract-verification"
-  },
-  source: {
-    primary: {
-      key: GetContractVerificationStatusQuery.meta.key,
-      version: GetContractVerificationStatusQuery.meta.version
-    }
-  },
-  view: {
-    kind: "table",
-    fields: [
-      {
-        key: "name",
-        label: "Contract / Endpoint / Event",
-        dataPath: "name"
-      },
-      {
-        key: "timeSinceVerified",
-        label: "Time since verified",
-        dataPath: "lastVerifiedDate"
-      },
-      {
-        key: "driftMismatches",
-        label: "Drift debt",
-        dataPath: "driftMismatches",
-        format: "number",
-        sortable: true
-      },
-      {
-        key: "surfaces",
-        label: "Surfaces covered",
-        dataPath: "surfaces",
-        format: "badge"
-      },
-      {
-        key: "lastVerifiedSha",
-        label: "Last verified commit",
-        dataPath: "lastVerifiedSha",
-        width: "sm"
-      }
-    ],
-    primaryField: "name",
-    secondaryFields: ["driftMismatches", "timeSinceVerified"],
-    columns: [
-      { field: "name", width: "lg" },
-      { field: "lastVerifiedSha", width: "sm" },
-      { field: "timeSinceVerified", width: "sm" },
-      { field: "surfaces", width: "md" },
-      { field: "driftMismatches", width: "xs", align: "right" }
-    ]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-
-// src/operations/report/index.ts
-var getContractVerificationStatusHandler = async (input, _ctx) => {
-  try {
-    const cmdProcess = Bun.spawn(["contractspec", "impl", "status", "--format", "json", "--all"], {
-      cwd: input.projectPath
-    });
-    const cmdStdout = await cmdProcess.stdout;
-    const output = await Bun.readableStreamToText(cmdStdout);
-    if (!output) {
-      return { contracts: [] };
-    }
-    const cliOutput = JSON.parse(output);
-    const contracts = [];
-    for (const spec of cliOutput.results || []) {
-      const contract = {
-        name: spec.specKey,
-        lastVerifiedSha: spec.specHash,
-        lastVerifiedDate: spec.specHash ? new Date().toISOString() : undefined,
-        surfaces: spec.implementations.filter((impl) => impl.exists).map((impl) => impl.type),
-        driftMismatches: spec.implementations.filter((impl) => !impl.exists).length
-      };
-      contracts.push(contract);
-    }
-    return { contracts };
-  } catch (error) {
-    console.error("Failed to get contract verification status:", error);
-    return { contracts: [] };
-  }
-};
-function registerReportContracts(registry) {
-  installOp(registry, GetContractVerificationStatusQuery, getContractVerificationStatusHandler);
-  return registry;
-}
-// src/integrations/openbanking/models.ts
-import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
-var BankAccountRecord = new SchemaModel2({
-  name: "BankAccountRecord",
-  description: "Canonical representation of a bank account synced from an open banking provider.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    institutionId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    institutionName: {
-      type: ScalarTypeEnum2.NonEmptyString(),
-      isOptional: false
-    },
-    institutionLogoUrl: { type: ScalarTypeEnum2.URL(), isOptional: true },
-    iban: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    bic: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    accountType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    displayName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    accountNumberMasked: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    productCode: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    balance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
-    availableBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    lastSyncedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
-  }
-});
-var BankTransactionRecord = new SchemaModel2({
-  name: "BankTransactionRecord",
-  description: "Canonical transaction entry mapped from Powens into the open banking ledger.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    amount: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    date: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    bookingDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    valueDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    counterpartyName: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    counterpartyAccount: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    merchantCategoryCode: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    rawCategory: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    standardizedCategory: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    transactionType: {
-      type: ScalarTypeEnum2.NonEmptyString(),
-      isOptional: false
-    },
-    status: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    runningBalance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var AccountBalanceRecord = new SchemaModel2({
-  name: "AccountBalanceRecord",
-  description: "Canonical balance snapshot computed from Powens balance payloads.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    balanceType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    currentBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: false
-    },
-    availableBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    lastUpdatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
-  }
-});
-
-// src/integrations/openbanking/telemetry.ts
-var OPENBANKING_PII_FIELDS = [
-  "iban",
-  "bic",
-  "accountNumberMasked",
-  "accountNumber",
-  "counterpartyName",
-  "counterpartyAccount",
-  "description",
-  "merchantName",
-  "merchantCategoryCode",
-  "reference"
-];
-var OPENBANKING_TELEMETRY_EVENTS = {
-  accountsSynced: "openbanking.accounts.synced",
-  accountsSyncFailed: "openbanking.accounts.sync_failed",
-  transactionsSynced: "openbanking.transactions.synced",
-  transactionsSyncFailed: "openbanking.transactions.sync_failed",
-  balancesRefreshed: "openbanking.balances.refreshed",
-  balancesRefreshFailed: "openbanking.balances.refresh_failed",
-  overviewGenerated: "openbanking.overview.generated"
-};
-function redactOpenBankingTelemetryPayload(payload) {
-  const redacted = {};
-  for (const [key, value] of Object.entries(payload)) {
-    if (OPENBANKING_PII_FIELDS.includes(key)) {
-      redacted[key] = maskValue(value);
-    } else if (Array.isArray(value)) {
-      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactOpenBankingTelemetryPayload(item) : item);
-    } else if (typeof value === "object" && value !== null) {
-      redacted[key] = redactOpenBankingTelemetryPayload(value);
-    } else {
-      redacted[key] = value;
-    }
-  }
-  return redacted;
-}
-function maskValue(value) {
-  if (value == null)
-    return "";
-  const str = String(value);
-  if (str.length <= 4)
-    return "*".repeat(str.length);
-  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
-}
-
-// src/integrations/openbanking/contracts/accounts.ts
-import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
-var OpenBankingListAccountsInput = new SchemaModel3({
-  name: "OpenBankingListAccountsInput",
-  description: "Parameters for listing bank accounts through the open banking provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
-    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    institutionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    cursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    pageSize: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
-  }
-});
-var OpenBankingListAccountsOutput = new SchemaModel3({
-  name: "OpenBankingListAccountsOutput",
-  description: "Paginated list of bank accounts available to the tenant and user.",
-  fields: {
-    accounts: {
-      type: BankAccountRecord,
-      isOptional: false,
-      isArray: true
-    },
-    nextCursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingGetAccountInput = new SchemaModel3({
-  name: "OpenBankingGetAccountInput",
-  description: "Parameters for retrieving a specific bank account.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    includeLatestTransactions: {
-      type: ScalarTypeEnum3.Boolean(),
-      isOptional: true
-    }
-  }
-});
-var OpenBankingSyncAccountsInput = new SchemaModel3({
-  name: "OpenBankingSyncAccountsInput",
-  description: "Command payload to trigger an account synchronisation against the open banking provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.ID(), isOptional: true },
-    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    accountIds: {
-      type: ScalarTypeEnum3.ID(),
-      isArray: true,
-      isOptional: true
-    },
-    forceFullRefresh: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    triggerWorkflows: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingSyncAccountsOutput = new SchemaModel3({
-  name: "OpenBankingSyncAccountsOutput",
-  description: "Result of a bank account synchronisation run.",
-  fields: {
-    synced: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    failed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    errors: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    },
-    nextSyncSuggestedAt: {
-      type: ScalarTypeEnum3.DateTime(),
-      isOptional: true
-    }
-  }
-});
-var OpenBankingListAccounts = defineQuery({
-  meta: {
-    key: "openbanking.accounts.list",
-    version: "1.0.0",
-    description: "List bank accounts available to a tenant/user via Powens Open Banking.",
-    goal: "Provide downstream workflows with the set of accounts accessible via the configured open banking connection.",
-    context: "Used by Pocket Family Office dashboards and sync workflows to enumerate bank accounts prior to syncing balances or transactions.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingListAccountsInput,
-    output: OpenBankingListAccountsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingGetAccount = defineQuery({
-  meta: {
-    key: "openbanking.accounts.get",
-    version: "1.0.0",
-    description: "Retrieve the canonical bank account record for the given account identifier.",
-    goal: "Allow user-facing experiences and automations to display up-to-date account metadata.",
-    context: "Invoked by UI surfaces and workflow automation steps that require detailed metadata for a specific bank account.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingGetAccountInput,
-    output: BankAccountRecord
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingSyncAccounts = defineCommand({
-  meta: {
-    key: "openbanking.accounts.sync",
-    version: "1.0.0",
-    description: "Initiate a synchronisation run to refresh bank account metadata from Powens.",
-    goal: "Keep canonical bank account records aligned with the external open banking provider.",
-    context: "Triggered by scheduled workflows or manual operator actions to reconcile account metadata prior to transaction/balance syncs.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingSyncAccountsInput,
-    output: OpenBankingSyncAccountsOutput
-  },
-  policy: {
-    auth: "admin"
-  },
-  telemetry: {
-    success: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSynced },
-      properties: ({ input, output }) => {
-        const payload = input;
-        const result = output;
-        return {
-          tenantId: payload?.tenantId,
-          connectionId: payload?.connectionId,
-          synced: result?.synced,
-          failed: result?.failed
-        };
-      }
-    },
-    failure: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSyncFailed },
-      properties: ({ input, error }) => {
-        const payload = input;
-        return {
-          tenantId: payload?.tenantId,
-          connectionId: payload?.connectionId,
-          error: error instanceof Error ? error.message : String(error ?? "unknown")
-        };
-      }
-    }
-  }
-});
-var openBankingAccountContracts = {
-  OpenBankingListAccounts,
-  OpenBankingGetAccount,
-  OpenBankingSyncAccounts
-};
-function registerOpenBankingAccountContracts(registry2) {
-  return registry2.register(OpenBankingListAccounts).register(OpenBankingGetAccount).register(OpenBankingSyncAccounts);
-}
-export {
-  registerOpenBankingAccountContracts,
-  openBankingAccountContracts,
-  OpenBankingSyncAccounts,
-  OpenBankingListAccounts,
-  OpenBankingGetAccount
-};