cc-peer 1.0.0 → 1.1.1

package/dist/cc-peer.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/cc-peer.ts
-const CC_PEER_VERSION = "0.0.0";
-//#endregion
-exports.CC_PEER_VERSION = CC_PEER_VERSION;
+const require_cc_peer = require("./cc-peer-CH38-mD2.cjs");
+exports.CC_PEER_VERSION = require_cc_peer.CC_PEER_VERSION;
+exports.CcPeer = require_cc_peer.CcPeer;

package/dist/cc-peer.d.cts

@@ -1,3 +1,304 @@
+import { EventEmitter } from "node:events";
+import { z } from "zod";
+//#region src/adapters/node/paths.d.ts
+interface PathConfig {
+  homeDir?: string;
+  socketDir?: string;
+}
+//#endregion
+//#region src/ports/transport.d.ts
+/** Transport port: per-exchange connections and the listening inbox. */
+interface Transport {
+  /**
+   * One connection, one write of the given lines (each newline-terminated), then close after a short linger. Mirrors the reference client's `Pe`.
+   */
+  connectWrite: (socketPath: string, lines: readonly string[], lingerMs?: number) => Promise<void>;
+  /** Probe whether a socket accepts connections (roster admission uses this). */
+  probe: (socketPath: string) => Promise<boolean>;
+  listen: (socketPath: string, onConnection: (conn: Readonly<InboundConnection>) => void) => Promise<ListeningSocket>;
+}
+interface InboundConnection {
+  /** Resolves once the kernel reports the connecting process's pid (macOS). */
+  peerPid: () => number | undefined;
+  readLines: () => AsyncIterable<string>;
+  close: () => void;
+}
+interface ListeningSocket {
+  socketPath: string;
+  close: () => Promise<void>;
+}
+//#endregion
+//#region src/schemas/registry.d.ts
+/** One entry of the ~/.claude/sessions/<pid>.json registry. */
+declare const RegistryEntrySchema: z.ZodObject<{
+  pid: z.ZodNumber;
+  sessionId: z.ZodString;
+  cwd: z.ZodString;
+  startedAt: z.ZodNumber;
+  procStart: z.ZodString;
+  version: z.ZodString;
+  peerProtocol: z.ZodNumber;
+  peerFeatures: z.ZodArray<z.ZodEnum<{
+    notify_idle: "notify_idle";
+    reply_across_default_dirs: "reply_across_default_dirs";
+    artifact_yield: "artifact_yield";
+  }> & {
+    is(value: unknown): value is "notify_idle" | "reply_across_default_dirs" | "artifact_yield";
+  }>;
+  kind: z.ZodEnum<{
+    interactive: "interactive";
+    bg: "bg";
+    daemon: "daemon";
+    "daemon-worker": "daemon-worker";
+  }> & {
+    is(value: unknown): value is "interactive" | "bg" | "daemon" | "daemon-worker";
+  };
+  entrypoint: z.ZodString;
+  pidDomain: z.ZodString;
+  messagingSocketPath: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  nameSource: z.ZodOptional<z.ZodEnum<{
+    user: "user";
+    peer: "peer";
+    derived: "derived";
+    collision: "collision";
+    auto: "auto";
+    hook: "hook";
+  }> & {
+    is(value: unknown): value is "user" | "peer" | "derived" | "collision" | "auto" | "hook";
+  }>;
+  nameSince: z.ZodOptional<z.ZodNumber>;
+  updatedAt: z.ZodNumber;
+  status: z.ZodOptional<z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+    shell: "shell";
+    waiting: "waiting";
+  }> & {
+    is(value: unknown): value is "idle" | "busy" | "shell" | "waiting";
+  }>;
+  statusUpdatedAt: z.ZodOptional<z.ZodNumber>;
+  bridgeSessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    pid: number;
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    procStart: string;
+    version: string;
+    peerProtocol: number;
+    peerFeatures: ("notify_idle" | "reply_across_default_dirs" | "artifact_yield")[];
+    kind: "interactive" | "bg" | "daemon" | "daemon-worker";
+    entrypoint: string;
+    pidDomain: string;
+    messagingSocketPath: string;
+    updatedAt: number;
+    name?: string | undefined;
+    nameSource?: "user" | "peer" | "derived" | "collision" | "auto" | "hook" | undefined;
+    nameSince?: number | undefined;
+    status?: "idle" | "busy" | "shell" | "waiting" | undefined;
+    statusUpdatedAt?: number | undefined;
+    bridgeSessionId?: string | undefined;
+  };
+};
+type RegistryEntry = z.infer<typeof RegistryEntrySchema>;
+//#endregion
+//#region src/ports/registry-store.d.ts
+/** Registry port: the ~/.claude/sessions/<pid>.json store. */
+interface RegistryStore {
+  list: () => Promise<RegistryEntry[]>;
+  read: (pid: number) => Promise<RegistryEntry | undefined>;
+  write: (entry: RegistryEntry) => Promise<void>;
+  /** Heartbeat: bump updatedAt/statusUpdatedAt without rewriting the rest. */
+  touch: (pid: number) => Promise<void>;
+  remove: (pid: number) => Promise<void>;
+}
+//#endregion
+//#region src/schemas/keyfile.d.ts
+/** The auth key a session publishes next to its socket. */
+declare const PeerKeyFileSchema: z.ZodObject<{
+  peerToken: z.ZodString;
+  procStart: z.ZodString;
+  pidDomain: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    peerToken: string;
+    procStart: string;
+    pidDomain: string;
+  };
+};
+type PeerKeyFile = z.infer<typeof PeerKeyFileSchema>;
+//#endregion
+//#region src/ports/key-store.d.ts
+/** Key-store port: auth keys published next to each session socket. */
+interface KeyStore {
+  readForSocket: (socketPath: string) => Promise<PeerKeyFile | undefined>;
+  /** Write our own key file for the socket we own. */
+  writeForSocket: (socketPath: string, keyFile: Readonly<PeerKeyFile>) => Promise<void>;
+  removeForSocket: (socketPath: string) => Promise<void>;
+}
+//#endregion
+//#region src/ports/proc-info.d.ts
+/** Process-info port: the liveness and proc-start facts the roster needs. */
+interface ProcInfo {
+  alive: (pid: number) => Promise<boolean>;
+  /**
+   * The process start string, byte-equal to `LC_ALL=C TZ=UTC ps -o lstart=` output — the exact value the receiver's registry byte-compares against.
+   */
+  lstart: (pid: number) => Promise<string | undefined>;
+}
+//#endregion
+//#region src/ports/clock.d.ts
+/** Clock port: injectable time for pacer/refill and freshness windows. */
+interface Clock {
+  nowMs: () => number;
+}
+//#endregion
+//#region src/schemas/wire.d.ts
+declare const PeerMessageStatusSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_message_status">;
+  status: z.ZodEnum<{
+    held: "held";
+    delivered: "delivered";
+    denied: "denied";
+    expired: "expired";
+    dropped: "dropped";
+  }>;
+  reason: z.ZodString;
+  from: z.ZodString;
+  orig_msg_id: z.ZodString;
+  status_detail: z.ZodOptional<z.ZodString>;
+  drop_reason: z.ZodOptional<z.ZodEnum<{
+    "rate-limited": "rate-limited";
+    duplicate: "duplicate";
+    "hop-loop": "hop-loop";
+    "hop-runaway": "hop-runaway";
+    "queue-full": "queue-full";
+  }> & {
+    is(value: unknown): value is "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full";
+  }>;
+  dropped_msg_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_message_status";
+    status: "held" | "delivered" | "denied" | "expired" | "dropped";
+    reason: string;
+    from: string;
+    orig_msg_id: string;
+    msgV: number;
+    msg_id: string;
+    status_detail?: string | undefined;
+    drop_reason?: "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full" | undefined;
+    dropped_msg_ids?: string[] | undefined;
+  };
+};
+type PeerMessageStatus = z.infer<typeof PeerMessageStatusSchema>;
+declare const PeerIdleNoticeSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_idle_notice">;
+  orig_msg_id: z.ZodString;
+  state: z.ZodEnum<{
+    idle: "idle";
+    exited: "exited";
+  }>;
+  finished_at: z.ZodNumber;
+  detail: z.ZodOptional<z.ZodString>;
+  from: z.ZodString;
+  from_mode: z.ZodOptional<z.ZodEnum<{
+    bypass: "bypass";
+    prompting: "prompting";
+  }>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_idle_notice";
+    orig_msg_id: string;
+    state: "idle" | "exited";
+    finished_at: number;
+    from: string;
+    msgV: number;
+    msg_id: string;
+    detail?: string | undefined;
+    from_mode?: "bypass" | "prompting" | undefined;
+  };
+};
+type PeerIdleNotice = z.infer<typeof PeerIdleNoticeSchema>;
+//#endregion
 //#region src/cc-peer.d.ts
+/** Package version placeholder until semantic-release owns it. */
 export declare const CC_PEER_VERSION = "0.0.0";
+/** How a target can be addressed. */
+export type PeerRef = {
+  pid: number;
+} | {
+  name: string;
+} | {
+  address: string;
+};
+export interface CcPeerOptions extends PathConfig {
+  name?: string;
+  sessionId?: string;
+  heartbeatMs?: number;
+  logger?: (message: string) => void;
+}
+export interface SendOptions {
+  priority?: "next" | "later";
+  /** Attaches from-mode attestation; false deliberately sends unattested (recipient holds it). */
+  fromMode?: "bypass" | "prompting" | false;
+  /** When set, must match the receiver's sessionId or the frame is silently dropped. */
+  sessionId?: string;
+}
+export interface InboundMessage {
+  from?: string;
+  fromSession?: string;
+  fromName?: string;
+  fromMode?: "bypass" | "prompting";
+  hopChain?: string[];
+  body: string;
+  msgId: string;
+}
+export type Receipt = PeerMessageStatus;
+export type IdleNotice = PeerIdleNotice;
+interface Deps {
+  transport: Transport;
+  registry: RegistryStore;
+  keys: KeyStore;
+  procInfo: ProcInfo;
+  clock: Clock;
+}
+/**
+ * A registered peer on Claude Code's cross-session mesh. Receipts and idle notices only reach the process that owns the listening socket (the protocol verifies return addresses via kernel peer pids), so do not split sending and listening across differently-owned processes.
+ */
+export declare class CcPeer extends EventEmitter {
+  private readonly options;
+  private readonly deps;
+  private listening;
+  private heartbeatTimer;
+  private ownKey;
+  private readonly pacer;
+  private readonly log;
+  private stopped;
+  constructor(options: Readonly<CcPeerOptions>, deps: Deps);
+  static create(options?: Readonly<CcPeerOptions>): Promise<CcPeer>;
+  private start;
+  private buildRegistryEntry;
+  roster(): Promise<RegistryEntry[]>;
+  send(target: PeerRef, body: string, options?: Readonly<SendOptions>): Promise<{
+    msgId: string;
+  }>;
+  private pacedSend;
+  subscribeIdle(target: PeerRef): Promise<{
+    msgId: string;
+  }>;
+  private resolveTarget;
+  private handleConnection;
+  stop(): Promise<void>;
+}
 //#endregion

package/dist/cc-peer.d.mts

@@ -1,3 +1,304 @@
+import { EventEmitter } from "node:events";
+import { z } from "zod";
+//#region src/adapters/node/paths.d.ts
+interface PathConfig {
+  homeDir?: string;
+  socketDir?: string;
+}
+//#endregion
+//#region src/ports/transport.d.ts
+/** Transport port: per-exchange connections and the listening inbox. */
+interface Transport {
+  /**
+   * One connection, one write of the given lines (each newline-terminated), then close after a short linger. Mirrors the reference client's `Pe`.
+   */
+  connectWrite: (socketPath: string, lines: readonly string[], lingerMs?: number) => Promise<void>;
+  /** Probe whether a socket accepts connections (roster admission uses this). */
+  probe: (socketPath: string) => Promise<boolean>;
+  listen: (socketPath: string, onConnection: (conn: Readonly<InboundConnection>) => void) => Promise<ListeningSocket>;
+}
+interface InboundConnection {
+  /** Resolves once the kernel reports the connecting process's pid (macOS). */
+  peerPid: () => number | undefined;
+  readLines: () => AsyncIterable<string>;
+  close: () => void;
+}
+interface ListeningSocket {
+  socketPath: string;
+  close: () => Promise<void>;
+}
+//#endregion
+//#region src/schemas/registry.d.ts
+/** One entry of the ~/.claude/sessions/<pid>.json registry. */
+declare const RegistryEntrySchema: z.ZodObject<{
+  pid: z.ZodNumber;
+  sessionId: z.ZodString;
+  cwd: z.ZodString;
+  startedAt: z.ZodNumber;
+  procStart: z.ZodString;
+  version: z.ZodString;
+  peerProtocol: z.ZodNumber;
+  peerFeatures: z.ZodArray<z.ZodEnum<{
+    notify_idle: "notify_idle";
+    reply_across_default_dirs: "reply_across_default_dirs";
+    artifact_yield: "artifact_yield";
+  }> & {
+    is(value: unknown): value is "notify_idle" | "reply_across_default_dirs" | "artifact_yield";
+  }>;
+  kind: z.ZodEnum<{
+    interactive: "interactive";
+    bg: "bg";
+    daemon: "daemon";
+    "daemon-worker": "daemon-worker";
+  }> & {
+    is(value: unknown): value is "interactive" | "bg" | "daemon" | "daemon-worker";
+  };
+  entrypoint: z.ZodString;
+  pidDomain: z.ZodString;
+  messagingSocketPath: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  nameSource: z.ZodOptional<z.ZodEnum<{
+    user: "user";
+    peer: "peer";
+    derived: "derived";
+    collision: "collision";
+    auto: "auto";
+    hook: "hook";
+  }> & {
+    is(value: unknown): value is "user" | "peer" | "derived" | "collision" | "auto" | "hook";
+  }>;
+  nameSince: z.ZodOptional<z.ZodNumber>;
+  updatedAt: z.ZodNumber;
+  status: z.ZodOptional<z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+    shell: "shell";
+    waiting: "waiting";
+  }> & {
+    is(value: unknown): value is "idle" | "busy" | "shell" | "waiting";
+  }>;
+  statusUpdatedAt: z.ZodOptional<z.ZodNumber>;
+  bridgeSessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    pid: number;
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    procStart: string;
+    version: string;
+    peerProtocol: number;
+    peerFeatures: ("notify_idle" | "reply_across_default_dirs" | "artifact_yield")[];
+    kind: "interactive" | "bg" | "daemon" | "daemon-worker";
+    entrypoint: string;
+    pidDomain: string;
+    messagingSocketPath: string;
+    updatedAt: number;
+    name?: string | undefined;
+    nameSource?: "user" | "peer" | "derived" | "collision" | "auto" | "hook" | undefined;
+    nameSince?: number | undefined;
+    status?: "idle" | "busy" | "shell" | "waiting" | undefined;
+    statusUpdatedAt?: number | undefined;
+    bridgeSessionId?: string | undefined;
+  };
+};
+type RegistryEntry = z.infer<typeof RegistryEntrySchema>;
+//#endregion
+//#region src/ports/registry-store.d.ts
+/** Registry port: the ~/.claude/sessions/<pid>.json store. */
+interface RegistryStore {
+  list: () => Promise<RegistryEntry[]>;
+  read: (pid: number) => Promise<RegistryEntry | undefined>;
+  write: (entry: RegistryEntry) => Promise<void>;
+  /** Heartbeat: bump updatedAt/statusUpdatedAt without rewriting the rest. */
+  touch: (pid: number) => Promise<void>;
+  remove: (pid: number) => Promise<void>;
+}
+//#endregion
+//#region src/schemas/keyfile.d.ts
+/** The auth key a session publishes next to its socket. */
+declare const PeerKeyFileSchema: z.ZodObject<{
+  peerToken: z.ZodString;
+  procStart: z.ZodString;
+  pidDomain: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    peerToken: string;
+    procStart: string;
+    pidDomain: string;
+  };
+};
+type PeerKeyFile = z.infer<typeof PeerKeyFileSchema>;
+//#endregion
+//#region src/ports/key-store.d.ts
+/** Key-store port: auth keys published next to each session socket. */
+interface KeyStore {
+  readForSocket: (socketPath: string) => Promise<PeerKeyFile | undefined>;
+  /** Write our own key file for the socket we own. */
+  writeForSocket: (socketPath: string, keyFile: Readonly<PeerKeyFile>) => Promise<void>;
+  removeForSocket: (socketPath: string) => Promise<void>;
+}
+//#endregion
+//#region src/ports/proc-info.d.ts
+/** Process-info port: the liveness and proc-start facts the roster needs. */
+interface ProcInfo {
+  alive: (pid: number) => Promise<boolean>;
+  /**
+   * The process start string, byte-equal to `LC_ALL=C TZ=UTC ps -o lstart=` output — the exact value the receiver's registry byte-compares against.
+   */
+  lstart: (pid: number) => Promise<string | undefined>;
+}
+//#endregion
+//#region src/ports/clock.d.ts
+/** Clock port: injectable time for pacer/refill and freshness windows. */
+interface Clock {
+  nowMs: () => number;
+}
+//#endregion
+//#region src/schemas/wire.d.ts
+declare const PeerMessageStatusSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_message_status">;
+  status: z.ZodEnum<{
+    held: "held";
+    delivered: "delivered";
+    denied: "denied";
+    expired: "expired";
+    dropped: "dropped";
+  }>;
+  reason: z.ZodString;
+  from: z.ZodString;
+  orig_msg_id: z.ZodString;
+  status_detail: z.ZodOptional<z.ZodString>;
+  drop_reason: z.ZodOptional<z.ZodEnum<{
+    "rate-limited": "rate-limited";
+    duplicate: "duplicate";
+    "hop-loop": "hop-loop";
+    "hop-runaway": "hop-runaway";
+    "queue-full": "queue-full";
+  }> & {
+    is(value: unknown): value is "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full";
+  }>;
+  dropped_msg_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_message_status";
+    status: "held" | "delivered" | "denied" | "expired" | "dropped";
+    reason: string;
+    from: string;
+    orig_msg_id: string;
+    msgV: number;
+    msg_id: string;
+    status_detail?: string | undefined;
+    drop_reason?: "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full" | undefined;
+    dropped_msg_ids?: string[] | undefined;
+  };
+};
+type PeerMessageStatus = z.infer<typeof PeerMessageStatusSchema>;
+declare const PeerIdleNoticeSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_idle_notice">;
+  orig_msg_id: z.ZodString;
+  state: z.ZodEnum<{
+    idle: "idle";
+    exited: "exited";
+  }>;
+  finished_at: z.ZodNumber;
+  detail: z.ZodOptional<z.ZodString>;
+  from: z.ZodString;
+  from_mode: z.ZodOptional<z.ZodEnum<{
+    bypass: "bypass";
+    prompting: "prompting";
+  }>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_idle_notice";
+    orig_msg_id: string;
+    state: "idle" | "exited";
+    finished_at: number;
+    from: string;
+    msgV: number;
+    msg_id: string;
+    detail?: string | undefined;
+    from_mode?: "bypass" | "prompting" | undefined;
+  };
+};
+type PeerIdleNotice = z.infer<typeof PeerIdleNoticeSchema>;
+//#endregion
 //#region src/cc-peer.d.ts
+/** Package version placeholder until semantic-release owns it. */
 export declare const CC_PEER_VERSION = "0.0.0";
+/** How a target can be addressed. */
+export type PeerRef = {
+  pid: number;
+} | {
+  name: string;
+} | {
+  address: string;
+};
+export interface CcPeerOptions extends PathConfig {
+  name?: string;
+  sessionId?: string;
+  heartbeatMs?: number;
+  logger?: (message: string) => void;
+}
+export interface SendOptions {
+  priority?: "next" | "later";
+  /** Attaches from-mode attestation; false deliberately sends unattested (recipient holds it). */
+  fromMode?: "bypass" | "prompting" | false;
+  /** When set, must match the receiver's sessionId or the frame is silently dropped. */
+  sessionId?: string;
+}
+export interface InboundMessage {
+  from?: string;
+  fromSession?: string;
+  fromName?: string;
+  fromMode?: "bypass" | "prompting";
+  hopChain?: string[];
+  body: string;
+  msgId: string;
+}
+export type Receipt = PeerMessageStatus;
+export type IdleNotice = PeerIdleNotice;
+interface Deps {
+  transport: Transport;
+  registry: RegistryStore;
+  keys: KeyStore;
+  procInfo: ProcInfo;
+  clock: Clock;
+}
+/**
+ * A registered peer on Claude Code's cross-session mesh. Receipts and idle notices only reach the process that owns the listening socket (the protocol verifies return addresses via kernel peer pids), so do not split sending and listening across differently-owned processes.
+ */
+export declare class CcPeer extends EventEmitter {
+  private readonly options;
+  private readonly deps;
+  private listening;
+  private heartbeatTimer;
+  private ownKey;
+  private readonly pacer;
+  private readonly log;
+  private stopped;
+  constructor(options: Readonly<CcPeerOptions>, deps: Deps);
+  static create(options?: Readonly<CcPeerOptions>): Promise<CcPeer>;
+  private start;
+  private buildRegistryEntry;
+  roster(): Promise<RegistryEntry[]>;
+  send(target: PeerRef, body: string, options?: Readonly<SendOptions>): Promise<{
+    msgId: string;
+  }>;
+  private pacedSend;
+  subscribeIdle(target: PeerRef): Promise<{
+    msgId: string;
+  }>;
+  private resolveTarget;
+  private handleConnection;
+  stop(): Promise<void>;
+}
 //#endregion

package/dist/cc-peer.mjs

@@ -1,4 +1,2 @@
-//#region src/cc-peer.ts
-const CC_PEER_VERSION = "0.0.0";
-//#endregion
-export { CC_PEER_VERSION };
+import { n as CcPeer, t as CC_PEER_VERSION } from "./cc-peer-BpNw-MoF.mjs";
+export { CC_PEER_VERSION, CcPeer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-peer",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Communicate with local Claude Code instances over their native cross-session peer messaging: send and receive messages, register as a named discoverable peer, receipts, idle subscriptions, and a REST facade via `npx cc-peer`.",
   "type": "module",
   "license": "MIT",