@classytic/party 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to `@classytic/party` are documented here. Adheres to
+[Keep a Changelog](https://keepachangelog.com/) and [SemVer](https://semver.org/).
+
+## [0.1.0] - 2026-07-13
+
+Initial release — the Party / Business-Partner identity kernel.
+
+- **`createParty({ connection, multiTenant?, … })`** engine factory; owns one
+  `Party` Mongoose model, an event dispatcher, and a `PartyPort`.
+- **`Party` model** — kind (person/company/group), non-exclusive roles,
+  contact points (normalized `identityKeys`), addresses, tax identity, B2B
+  `parentId`, 1:many `userLinks`, `externalRefs`, lifecycle (active/archived/merged).
+- **`resolveOrCreate`** — race-safe dedup by email/phone/vat/bin/externalRef;
+  unique multikey `identityKeys` index is the authoritative guard.
+- **`merge`** — non-lossy survivor absorption + terminal redirect; `snapshot`
+  follows the redirect. Runs in a transaction.
+- **Roles** — `addRole` / `removeRole`; **lifecycle** — `archive` / `restore`
+  via a `defineStateMachine` + `claim` CAS.
+- **`syncIdentity(id, input)`** — the canonical identity-mutation verb: merges
+  new contact points (deriving keys, extending `identityKeys`), updates
+  name/addresses/tax, emits `party:party.updated`. Hosts push a facet's current
+  identity here so the party stays the source of truth (idempotent).
+- **`PartyPort`** — the reusable identity contract for consuming domains.
+- **Events** — `party:party.*` with a Zod source catalog + no-drift test; P8.1
+  unit-of-work (`withTransaction` + `PENDING_EVENTS` + `flushPending`).
+- Thin identity (SAP Business-Partner shape) — domain facets stay in their own
+  packages keyed by `partyId`. Primitives reused for Address / PersonName /
+  ExternalRef / phone parsing. 28 tests (18 unit + 10 integration).
+- Toolchain: TypeScript 7, tsdown 0.22, ESM, `exactOptionalPropertyTypes`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Classytic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# @classytic/party
+
+**The Party / Business-Partner identity kernel for MongoDB.** One canonical
+identity per real-world person, company, or group — carrying non-exclusive roles
+(customer / supplier / contact / employee / partner), contact points, addresses,
+tax identity, B2B hierarchy, and 1:many auth-user links. With race-safe
+de-duplication, merge, and a reusable resolver port.
+
+Built on Mongoose + [`@classytic/mongokit`](https://npmjs.com/package/@classytic/mongokit)
++ [`@classytic/primitives`](https://npmjs.com/package/@classytic/primitives) +
+[`@classytic/repo-core`](https://npmjs.com/package/@classytic/repo-core). Any
+commerce / ERP / SaaS app on MongoDB can adopt it.
+
+## Why
+
+Most stacks model "the customer" in several places — a storefront customer, a
+CRM contact, an accounting partner, a payout recipient — none sharing an
+identity. That fragmentation is where "is this the same person?" bugs live.
+
+`party` is the **single identity spine**. It follows the **SAP Business Partner**
+shape: a *thin* identity that carries roles, and lets each domain keep its own
+**facet** keyed by `partyId`. It is deliberately **not** an Odoo `res.partner`
+god-object — no accounting accounts, credit limits, loyalty tiers, KYC, or
+payout methods live on the party. Those stay in `@classytic/ledger`,
+`@classytic/loyalty`, `@classytic/payee`, `@classytic/crm`, … and point at a
+`partyId`.
+
+```
+@classytic/party (WHO)  ← one deduped identity + roles
+   ├── ledger      finance facet   (AR/AP, credit, terms)   → partyId
+   ├── crm         funnel facet     (stage, campaigns)       → partyId
+   ├── loyalty     rewards facet    (points, tier)           → partyId
+   ├── payee       payout facet     (methods, KYC)           → partyId
+   ├── commission  earnings facet   (plans, records)         → partyId
+   └── referral    attribution      (who referred whom)      → partyId
+```
+
+## Install
+
+```bash
+npm i @classytic/party
+```
+
+Peers: `@classytic/mongokit >=3.20`, `@classytic/primitives >=0.9.1`,
+`@classytic/repo-core >=0.9`, `mongoose >=9.4.1`, `zod >=4`.
+
+## Quick start
+
+```ts
+import mongoose from 'mongoose';
+import { createParty } from '@classytic/party';
+
+const party = await createParty({
+  connection: mongoose.connection,
+  multiTenant: false, // identity is company-wide here; pass true for per-tenant SaaS
+});
+
+// Resolve-or-create by ANY identity signal — race-safe, dedup by email/phone/vat.
+const { party: ada, created } = await party.port.resolveOrCreate(
+  {
+    displayName: 'Ada Lovelace',
+    emails: ['ada@example.com'],
+    phones: ['+8801712345678'],
+    roles: ['customer'],
+  },
+  {},
+);
+
+// Same person, different casing + a role added → SAME party, no duplicate.
+await party.port.resolveOrCreate({ emails: ['ADA@example.com'], roles: ['supplier'] }, {});
+
+// Freeze a snapshot onto an order/invoice (never a live join).
+const snap = await party.port.snapshot(String(ada._id), {});
+
+// Merge a duplicate — survivor absorbs identity; the loser becomes a redirect.
+await party.repositories.party.merge(dupId, survivorId, {});
+```
+
+## The `PartyPort` — the reusable contract
+
+Consuming domains depend on `engine.port` (a `PartyPort`), not the models:
+
+```ts
+interface PartyPort<TParty> {
+  resolveOrCreate(input, ctx): Promise<{ party: TParty; created: boolean }>;
+  resolveMany(inputs, ctx): Promise<Array<{ party: TParty; created: boolean }>>;
+  snapshot(partyId, ctx): Promise<PartySnapshot>; // follows merge redirects
+}
+```
+
+Wire it into order / crm / ledger as the single identity source. Swap the
+kernel's storage without touching a consumer.
+
+## What it guarantees
+
+- **Race-safe dedup** — a unique multikey index on `identityKeys` is the
+  authoritative guard; concurrent creates collapse to one party.
+- **Non-lossy merge** — the survivor absorbs the loser's keys, roles, contacts,
+  refs, and user links; the loser stays as a terminal `merged` redirect, so
+  historical references (and `snapshot`) still resolve.
+- **Arc-native errors** — every throwable implements repo-core's `HttpError`.
+- **Event catalog** — `party:party.*` events with a Zod source catalog for arc's
+  `EventRegistry` (validation + OpenAPI). Bring any arc `EventTransport`.
+
+## Roles are flags, never tables
+
+A party with `roles: ['customer', 'supplier']` is simultaneously both. Grant with
+`addRole`, revoke with `removeRole`. No separate customer/vendor/contact
+entities — that's the duplication this kernel exists to remove.
+
+## License
+
+MIT

package/dist/events.d.ts

@@ -0,0 +1,238 @@
+import { z } from "zod";
+import { DomainEvent, EventHandler, EventMeta, EventTransport } from "@classytic/primitives/events";
+import { Types } from "mongoose";
+import { OperationContext } from "@classytic/primitives/context";
+import "@classytic/primitives/reference";
+import "@classytic/primitives/person";
+import "@classytic/primitives/address";
+import { OutboxStore } from "@classytic/primitives/outbox";
+//#region src/events/event-constants.d.ts
+/** PACKAGE_RULES §12: `package:resource.verb`. Emit ONLY these catalog names. */
+declare const PARTY_EVENTS: {
+  readonly CREATED: 'party:party.created';
+  readonly UPDATED: 'party:party.updated';
+  readonly ROLE_ADDED: 'party:party.role_added';
+  readonly ROLE_REMOVED: 'party:party.role_removed';
+  readonly USER_LINKED: 'party:party.user_linked';
+  readonly EXTERNAL_REF_ATTACHED: 'party:party.external_ref_attached';
+  readonly ARCHIVED: 'party:party.archived';
+  readonly RESTORED: 'party:party.restored';
+  readonly MERGED: 'party:party.merged';
+};
+type PartyEventName = (typeof PARTY_EVENTS)[keyof typeof PARTY_EVENTS];
+//#endregion
+//#region src/domain/enums.d.ts
+/**
+ * Party-native enumerations.
+ *
+ * These are identity-kernel concepts (kind, role, lifecycle) — they have no
+ * one-to-one primitive to subset, so they are declared here as the source of
+ * truth. Domain FACETS (finance terms, CRM stage, loyalty tier) live in their
+ * OWN packages keyed by `partyId`; they are deliberately NOT modelled here —
+ * that separation is the whole point of the SAP-style thin identity kernel
+ * (vs. Odoo's `res.partner` god-object).
+ */
+/** What kind of real-world entity a party is. */
+declare const PARTY_KINDS: readonly ['person', 'company', 'group'];
+type PartyKind = (typeof PARTY_KINDS)[number];
+/**
+ * Roles a party plays. NON-exclusive — one party can be a customer AND a
+ * supplier AND a contact simultaneously (the exact de-duplication a shared
+ * identity buys you). Roles are additive flags, never separate entities.
+ */
+declare const PARTY_ROLES: readonly ['customer', 'supplier', 'contact', 'employee', 'partner'];
+type PartyRole = (typeof PARTY_ROLES)[number];
+//#endregion
+//#region src/events/event-payloads.d.ts
+interface PartyCreatedPayload {
+  partyId: string;
+  kind: PartyKind;
+  displayName: string;
+  roles: PartyRole[];
+  organizationId?: string;
+}
+interface PartyUpdatedPayload {
+  partyId: string;
+  /** Top-level fields that changed on this write. */
+  changed: string[];
+}
+interface PartyRoleChangedPayload {
+  partyId: string;
+  role: PartyRole;
+}
+interface PartyUserLinkedPayload {
+  partyId: string;
+  userId: string;
+}
+interface PartyExternalRefAttachedPayload {
+  partyId: string;
+  sourceModel: string;
+  sourceId: string;
+}
+interface PartyLifecyclePayload {
+  partyId: string;
+}
+interface PartyMergedPayload {
+  /** The party that was merged away (now a redirect). */
+  sourceId: string;
+  /** The surviving party. */
+  targetId: string;
+  /** How many identity keys the survivor absorbed. */
+  absorbedKeys: number;
+}
+/** Name → payload map — subscribers get exact typing from the event name. */
+interface PartyEventPayloads {
+  [PARTY_EVENTS.CREATED]: PartyCreatedPayload;
+  [PARTY_EVENTS.UPDATED]: PartyUpdatedPayload;
+  [PARTY_EVENTS.ROLE_ADDED]: PartyRoleChangedPayload;
+  [PARTY_EVENTS.ROLE_REMOVED]: PartyRoleChangedPayload;
+  [PARTY_EVENTS.USER_LINKED]: PartyUserLinkedPayload;
+  [PARTY_EVENTS.EXTERNAL_REF_ATTACHED]: PartyExternalRefAttachedPayload;
+  [PARTY_EVENTS.ARCHIVED]: PartyLifecyclePayload;
+  [PARTY_EVENTS.RESTORED]: PartyLifecyclePayload;
+  [PARTY_EVENTS.MERGED]: PartyMergedPayload;
+}
+//#endregion
+//#region src/events/event-catalog.d.ts
+interface PartyEventDefinition<TSchema extends z.ZodType = z.ZodType> {
+  name: string;
+  version: number;
+  description: string;
+  zodSchema: TSchema;
+  schema: Record<string, unknown>;
+  create(payload: z.infer<TSchema>, meta?: Partial<EventMeta>): DomainEvent<z.infer<TSchema>>;
+}
+declare const PartyCreated: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  kind: z.ZodEnum<{
+    company: "company";
+    group: "group";
+    person: "person";
+  }>;
+  displayName: z.ZodString;
+  roles: z.ZodArray<z.ZodEnum<{
+    contact: "contact";
+    customer: "customer";
+    employee: "employee";
+    partner: "partner";
+    supplier: "supplier";
+  }>>;
+  organizationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const PartyUpdated: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  changed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;
+declare const PartyRoleAdded: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  role: z.ZodEnum<{
+    contact: "contact";
+    customer: "customer";
+    employee: "employee";
+    partner: "partner";
+    supplier: "supplier";
+  }>;
+}, z.core.$strip>>;
+declare const PartyRoleRemoved: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  role: z.ZodEnum<{
+    contact: "contact";
+    customer: "customer";
+    employee: "employee";
+    partner: "partner";
+    supplier: "supplier";
+  }>;
+}, z.core.$strip>>;
+declare const PartyUserLinked: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  userId: z.ZodString;
+}, z.core.$strip>>;
+declare const PartyExternalRefAttached: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+  sourceModel: z.ZodString;
+  sourceId: z.ZodString;
+}, z.core.$strip>>;
+declare const PartyArchived: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+}, z.core.$strip>>;
+declare const PartyRestored: PartyEventDefinition<z.ZodObject<{
+  partyId: z.ZodString;
+}, z.core.$strip>>;
+declare const PartyMerged: PartyEventDefinition<z.ZodObject<{
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  absorbedKeys: z.ZodNumber;
+}, z.core.$strip>>;
+declare const partyEventDefinitions: ReadonlyArray<PartyEventDefinition>;
+//#endregion
+//#region src/domain/ports.d.ts
+/**
+ * Operation context threaded through every domain verb. Extends primitives'
+ * `OperationContext`; narrows the id fields to what Mongoose stores cleanly.
+ */
+interface PartyContext extends OperationContext {
+  organizationId?: string | Types.ObjectId;
+  actorId?: string | Types.ObjectId;
+  /** Mongo transaction session, passed straight to mongokit. */
+  session?: unknown;
+  /** Cooperative cancellation — threaded to mongokit at choke points. */
+  signal?: AbortSignal;
+  /** Retry policy for driver round-trips (mongokit `RetryPolicy`). */
+  retryPolicy?: unknown;
+}
+/** Minimal logger surface the in-process bus + repositories log through. */
+interface PartyLogger {
+  info?(msg: string, meta?: Record<string, unknown>): void;
+  warn?(msg: string, meta?: Record<string, unknown>): void;
+  error?(msg: string, meta?: Record<string, unknown>): void;
+  debug?(msg: string, meta?: Record<string, unknown>): void;
+}
+//#endregion
+//#region src/events/helpers.d.ts
+declare function createEvent<T>(type: string, payload: T, ctx?: PartyContext, meta?: Partial<EventMeta>): DomainEvent<T>;
+//#endregion
+//#region src/events/in-process-bus.d.ts
+declare class InProcessPartyBus implements EventTransport {
+  readonly name = "in-process-party";
+  private subs;
+  private readonly logger;
+  constructor(options?: {
+    logger?: PartyLogger | undefined;
+  });
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/events/dispatch.d.ts
+/** Context key carrying a post-commit publish queue (attached by `withTransaction`). */
+declare const PENDING_EVENTS: unique symbol;
+interface PartyEventDispatcherOptions {
+  transport: EventTransport;
+  outbox?: OutboxStore | undefined;
+  logger?: PartyLogger | undefined;
+}
+declare class PartyEventDispatcher {
+  readonly name: string;
+  private readonly transport;
+  private readonly outbox;
+  private readonly logger;
+  constructor(opts: PartyEventDispatcherOptions);
+  /** Raw publish — hosts and the unit-of-work flush use this. */
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  /**
+   * Route a domain event with full §P8 discipline. Reads the pending queue and
+   * session off `ctx`.
+   */
+  dispatch(event: DomainEvent, ctx: PartyContext): Promise<void>;
+  close(): Promise<void>;
+}
+/**
+ * Drain a pending-events queue to the transport AFTER the owning transaction
+ * commits. Per-event failures are swallowed — durable delivery is the outbox's
+ * job (PACKAGE_RULES §P8.1).
+ */
+declare function flushPending(dispatcher: PartyEventDispatcher, queue: DomainEvent[], logger?: PartyLogger): Promise<void>;
+//#endregion
+export { InProcessPartyBus, PARTY_EVENTS, PENDING_EVENTS, PartyArchived, PartyCreated, PartyCreatedPayload, PartyEventDefinition, PartyEventDispatcher, PartyEventDispatcherOptions, PartyEventName, PartyEventPayloads, PartyExternalRefAttached, PartyExternalRefAttachedPayload, PartyLifecyclePayload, PartyMerged, PartyMergedPayload, PartyRestored, PartyRoleAdded, PartyRoleChangedPayload, PartyRoleRemoved, PartyUpdated, PartyUpdatedPayload, PartyUserLinked, PartyUserLinkedPayload, createEvent, flushPending, partyEventDefinitions };

package/dist/events.js

@@ -0,0 +1,255 @@
+import { z } from "zod";
+import { createEvent as createEvent$1, matchEventPattern } from "@classytic/primitives/events";
+//#region src/events/event-constants.ts
+/** PACKAGE_RULES §12: `package:resource.verb`. Emit ONLY these catalog names. */
+const PARTY_EVENTS = {
+	CREATED: "party:party.created",
+	UPDATED: "party:party.updated",
+	ROLE_ADDED: "party:party.role_added",
+	ROLE_REMOVED: "party:party.role_removed",
+	USER_LINKED: "party:party.user_linked",
+	EXTERNAL_REF_ATTACHED: "party:party.external_ref_attached",
+	ARCHIVED: "party:party.archived",
+	RESTORED: "party:party.restored",
+	MERGED: "party:party.merged"
+};
+//#endregion
+//#region src/events/event-catalog.ts
+/**
+* Zod-source event catalog (PACKAGE_RULES §18). One Zod schema per event is the
+* single source of truth — runtime validation, static types, and arc's
+* `EventRegistry` (OpenAPI + `arc describe`) all derive from it. Structurally
+* identical to arc's `EventDefinitionOutput`; we never import arc.
+*
+* Timestamps use `z.iso.datetime()`, never `z.coerce.date()` (§25).
+*/
+function definePartyEvent(input) {
+	const { name, version = 1, description, zodSchema } = input;
+	return {
+		name,
+		version,
+		description,
+		zodSchema,
+		schema: z.toJSONSchema(zodSchema),
+		create(payload, meta) {
+			return createEvent$1(name, payload, {
+				source: "party",
+				...meta
+			});
+		}
+	};
+}
+const partyKind = z.enum([
+	"person",
+	"company",
+	"group"
+]);
+const partyRole = z.enum([
+	"customer",
+	"supplier",
+	"contact",
+	"employee",
+	"partner"
+]);
+const createdSchema = z.object({
+	partyId: z.string(),
+	kind: partyKind,
+	displayName: z.string(),
+	roles: z.array(partyRole),
+	organizationId: z.string().optional()
+});
+const updatedSchema = z.object({
+	partyId: z.string(),
+	changed: z.array(z.string())
+});
+const roleChangedSchema = z.object({
+	partyId: z.string(),
+	role: partyRole
+});
+const userLinkedSchema = z.object({
+	partyId: z.string(),
+	userId: z.string()
+});
+const externalRefSchema = z.object({
+	partyId: z.string(),
+	sourceModel: z.string(),
+	sourceId: z.string()
+});
+const lifecycleSchema = z.object({ partyId: z.string() });
+const mergedSchema = z.object({
+	sourceId: z.string(),
+	targetId: z.string(),
+	absorbedKeys: z.number().int().nonnegative()
+});
+const PartyCreated = definePartyEvent({
+	name: PARTY_EVENTS.CREATED,
+	description: "A new canonical party identity was created.",
+	zodSchema: createdSchema
+});
+const PartyUpdated = definePartyEvent({
+	name: PARTY_EVENTS.UPDATED,
+	description: "A party identity field changed.",
+	zodSchema: updatedSchema
+});
+const PartyRoleAdded = definePartyEvent({
+	name: PARTY_EVENTS.ROLE_ADDED,
+	description: "A role (customer/supplier/…) was granted to a party.",
+	zodSchema: roleChangedSchema
+});
+const PartyRoleRemoved = definePartyEvent({
+	name: PARTY_EVENTS.ROLE_REMOVED,
+	description: "A role was revoked from a party.",
+	zodSchema: roleChangedSchema
+});
+const PartyUserLinked = definePartyEvent({
+	name: PARTY_EVENTS.USER_LINKED,
+	description: "An auth user was linked to a party (1:many).",
+	zodSchema: userLinkedSchema
+});
+const PartyExternalRefAttached = definePartyEvent({
+	name: PARTY_EVENTS.EXTERNAL_REF_ATTACHED,
+	description: "An external-store reference was attached to a party (facet link).",
+	zodSchema: externalRefSchema
+});
+const PartyArchived = definePartyEvent({
+	name: PARTY_EVENTS.ARCHIVED,
+	description: "A party was archived.",
+	zodSchema: lifecycleSchema
+});
+const PartyRestored = definePartyEvent({
+	name: PARTY_EVENTS.RESTORED,
+	description: "An archived party was restored to active.",
+	zodSchema: lifecycleSchema
+});
+const PartyMerged = definePartyEvent({
+	name: PARTY_EVENTS.MERGED,
+	description: "A duplicate party was merged into a survivor; the source becomes a redirect.",
+	zodSchema: mergedSchema
+});
+const partyEventDefinitions = [
+	PartyCreated,
+	PartyUpdated,
+	PartyRoleAdded,
+	PartyRoleRemoved,
+	PartyUserLinked,
+	PartyExternalRefAttached,
+	PartyArchived,
+	PartyRestored,
+	PartyMerged
+];
+//#endregion
+//#region src/events/helpers.ts
+/**
+* `createEvent` — thin wrapper over primitives' `createEvent` that stamps
+* `source: 'party'` and lifts `actorId`/`organizationId`/`correlationId` off the
+* `PartyContext`. Use this instead of importing `createEvent` directly so the
+* source stamp + meta stay consistent (PACKAGE_RULES §14).
+*/
+function createEvent(type, payload, ctx, meta) {
+	return createEvent$1(type, payload, {
+		source: "party",
+		...ctx?.actorId !== void 0 ? { actorId: String(ctx.actorId) } : {},
+		...ctx?.organizationId !== void 0 ? { organizationId: String(ctx.organizationId) } : {},
+		...ctx?.correlationId !== void 0 ? { correlationId: ctx.correlationId } : {},
+		...meta
+	});
+}
+//#endregion
+//#region src/events/in-process-bus.ts
+/**
+* In-process event bus — default fallback when no `eventTransport` is given to
+* `createParty`. Structurally identical to arc's `MemoryEventTransport`;
+* pattern-matching delegates to primitives' `matchEventPattern` (PACKAGE_RULES
+* §13). Handler errors are swallowed-and-logged — emission never blocks writes.
+*/
+var InProcessPartyBus = class {
+	name = "in-process-party";
+	subs = [];
+	logger;
+	constructor(options) {
+		this.logger = options?.logger;
+	}
+	async publish(event) {
+		const matching = this.subs.filter((s) => matchEventPattern(s.pattern, event.type));
+		for (const sub of matching) try {
+			await sub.handler(event);
+		} catch (err) {
+			this.logger?.error?.(`[party] event handler error [${event.type}]`, { error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	async subscribe(pattern, handler) {
+		const sub = {
+			pattern,
+			handler
+		};
+		this.subs.push(sub);
+		return () => {
+			this.subs = this.subs.filter((s) => s !== sub);
+		};
+	}
+	async close() {
+		this.subs = [];
+	}
+};
+//#endregion
+//#region src/events/dispatch.ts
+/** Context key carrying a post-commit publish queue (attached by `withTransaction`). */
+const PENDING_EVENTS = Symbol.for("@classytic/party:pendingEvents");
+var PartyEventDispatcher = class {
+	name;
+	transport;
+	outbox;
+	logger;
+	constructor(opts) {
+		this.transport = opts.transport;
+		this.outbox = opts.outbox;
+		this.logger = opts.logger;
+		this.name = opts.transport.name;
+	}
+	/** Raw publish — hosts and the unit-of-work flush use this. */
+	publish(event) {
+		return this.transport.publish(event);
+	}
+	subscribe(pattern, handler) {
+		return this.transport.subscribe(pattern, handler);
+	}
+	/**
+	* Route a domain event with full §P8 discipline. Reads the pending queue and
+	* session off `ctx`.
+	*/
+	async dispatch(event, ctx) {
+		if (this.outbox) try {
+			await this.outbox.save(event, ctx.session !== void 0 ? { session: ctx.session } : {});
+		} catch (err) {
+			this.logger?.error?.(`[party] outbox.save failed for ${event.type}`, { error: err instanceof Error ? err.message : String(err) });
+			throw err;
+		}
+		const queue = ctx[PENDING_EVENTS];
+		if (Array.isArray(queue)) {
+			queue.push(event);
+			return;
+		}
+		try {
+			await this.transport.publish(event);
+		} catch (err) {
+			this.logger?.error?.(`[party] publish failed for ${event.type}`, { error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	async close() {
+		await this.transport.close?.();
+	}
+};
+/**
+* Drain a pending-events queue to the transport AFTER the owning transaction
+* commits. Per-event failures are swallowed — durable delivery is the outbox's
+* job (PACKAGE_RULES §P8.1).
+*/
+async function flushPending(dispatcher, queue, logger) {
+	for (const event of queue) try {
+		await dispatcher.publish(event);
+	} catch (err) {
+		logger?.error?.(`[party] post-commit publish failed for ${event.type}`, { error: err instanceof Error ? err.message : String(err) });
+	}
+}
+//#endregion
+export { InProcessPartyBus, PARTY_EVENTS, PENDING_EVENTS, PartyArchived, PartyCreated, PartyEventDispatcher, PartyExternalRefAttached, PartyMerged, PartyRestored, PartyRoleAdded, PartyRoleRemoved, PartyUpdated, PartyUserLinked, createEvent, flushPending, partyEventDefinitions };