@covenant-rpc/core 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @covenant-rpc/core
+
+## 0.1.3
+
+### Patch Changes
+
+- 8061179: Initial publish
+
+## 0.1.2
+
+### Patch Changes
+
+- Fix all packages

package/lib/channel.ts

@@ -0,0 +1,139 @@
+import { v } from "./validation";
+import type { ChannelDeclaration } from ".";
+import type { MaybePromise, ArrayToMap } from "./utils";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+
+export const channelErrorSchema = v.obj({
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  fault: v.union(v.literal("server"), v.literal("client"), v.literal("sidekick")),
+  message: v.string(),
+});
+export type ChannelError = v.Infer<typeof channelErrorSchema>;
+
+
+// sent from the client to the server
+export const channelConnectionRequestSchema = v.obj({
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  data: v.unknown(),
+});
+export type ChannelConnectionRequest = v.Infer<typeof channelConnectionRequestSchema>;
+
+// sent from the server back to the client to inform of a connection
+export const channelConnectionResponseSchema = v.obj({
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  result: v.union(
+    v.obj({
+      type: v.literal("OK"),
+      token: v.string(),
+    }),
+    v.obj({
+      type: v.literal("ERROR"),
+      error: channelErrorSchema,
+    })
+  )
+});
+export type ChannelConnectionResponse = v.Infer<typeof channelConnectionResponseSchema>;
+
+// sent from the server to the sidekick to inform of a new connection
+export const channelConnectionPayload = v.obj({
+  token: v.string(),
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  context: v.unknown(),
+});
+
+export type ChannelConnectionPayload = v.Infer<typeof channelConnectionPayload>;
+
+export const serverMessageSchema = v.obj({
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  data: v.unknown(),
+});
+export type ServerMessage = v.Infer<typeof serverMessageSchema>;
+
+export const serverMessageWithContext = v.obj({
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  data: v.unknown(),
+  context: v.unknown(),
+});
+export type ServerMessageWithContext = v.Infer<typeof serverMessageWithContext>;
+
+export interface ConnectionHandlerInputs<T, Params> {
+  inputs: T,
+  params: Params,
+  reject(reason: string, cause: "client" | "server"): never,
+}
+
+export interface MessageHandlerInputs<T, Params, Context> {
+  inputs: T,
+  params: Params,
+  context: Context,
+  error(reason: string, cause: "client" | "server"): never,
+}
+
+export type ChannelDefinition<T> = T extends ChannelDeclaration<
+  infer ClientMessage,
+  any,
+  infer ConnectionRequest,
+  infer ConnectionContext,
+  infer Params
+> ? {
+  onConnect: (i: ConnectionHandlerInputs<
+    StandardSchemaV1.InferOutput<ConnectionRequest>,
+    ArrayToMap<Params>
+  >) => MaybePromise<
+    StandardSchemaV1.InferOutput<ConnectionContext>
+  >;
+  onMessage: (i: MessageHandlerInputs<
+    StandardSchemaV1.InferOutput<ClientMessage>,
+    ArrayToMap<Params>,
+    StandardSchemaV1.InferOutput<ConnectionContext>
+  >) => MaybePromise<
+    void
+  >
+} : never
+
+export type InferChannelClientMessage<C> = C extends ChannelDeclaration<
+  infer ClientMessage,
+  any,
+  any,
+  any,
+  any
+> ? StandardSchemaV1.InferOutput<ClientMessage> : never
+
+export type InferChannelServerMessage<C> = C extends ChannelDeclaration<
+  any,
+  infer ServerMessage,
+  any,
+  any,
+  any
+> ? StandardSchemaV1.InferOutput<ServerMessage> : never
+
+export type InferChannelConnectionRequest<C> = C extends ChannelDeclaration<
+  any,
+  any,
+  infer ConnectionRequest,
+  any,
+  any
+> ? StandardSchemaV1.InferOutput<ConnectionRequest> : never
+
+export type InferChannelConnectionContext<C> = C extends ChannelDeclaration<
+  any,
+  any,
+  any,
+  infer ChannelContext,
+  any
+> ? StandardSchemaV1.InferOutput<ChannelContext> : never
+
+export type InferChannelParams<C> = C extends ChannelDeclaration<
+  any,
+  any,
+  any,
+  any,
+  infer Params
+> ? ArrayToMap<Params> : never

package/lib/errors.ts

@@ -0,0 +1,80 @@
+import type { ChannelError } from "./channel";
+import type { ProcedureError } from "./procedure";
+
+export class ThrowableProcedureError {
+  message: string;
+  httpCode: number;
+
+  constructor(message: string, httpCode: number) {
+    this.message = message;
+    this.httpCode = httpCode;
+  }
+
+  static fromError(error: Error): ThrowableProcedureError {
+    return new ThrowableProcedureError(error.message, 500);
+  }
+
+  static fromUnknown(k: unknown): ThrowableProcedureError {
+    return new ThrowableProcedureError(`Unknown error: ${k}`, 500);
+  }
+
+  toProcedureError(): ProcedureError {
+    return {
+      message: this.message,
+      code: this.httpCode,
+    }
+  }
+}
+
+
+export function procedureErrorFromUnknown(e: unknown) {
+  const err = e instanceof ThrowableProcedureError
+    ? e : e instanceof Error
+    ? ThrowableProcedureError.fromError(e)
+    : ThrowableProcedureError.fromUnknown(e);
+
+  return err.toProcedureError();
+}
+
+
+export class ThrowableChannelError {
+  message: string;
+  cause: "client" | "server" | "sidekick";
+  channel: string;
+  params: Record<string, string>;
+
+  constructor(message: string, channel: string, params: Record<string, string>, cause: "client" | "server" | "sidekick") {
+    this.message = message;
+    this.channel = channel;
+    this.params = params;
+    this.cause = cause;
+  }
+
+  static fromError(error: Error, channel: string, params: Record<string, string>): ThrowableChannelError {
+    return new ThrowableChannelError(error.message, channel, params, "server");
+  }
+
+  static fromUnknown(error: unknown, channel: string, params: Record<string, string>): ThrowableChannelError {
+    return new ThrowableChannelError(`Unknown error: ${error}`, channel, params, "server");
+  }
+
+
+  toChannelError(): ChannelError {
+    return {
+      channel: this.channel,
+      params: this.params,
+      message: this.message,
+      fault: this.cause,
+    }
+  }
+}
+
+
+export function channelErrorFromUnknown(e: unknown, channel: string, params: Record<string, string>) {
+  const err = e instanceof ThrowableChannelError
+    ? e : e instanceof Error
+    ? ThrowableChannelError.fromError(e, channel, params)
+    : ThrowableChannelError.fromUnknown(e, channel, params);
+
+  return err.toChannelError();
+}

package/lib/index.ts

@@ -0,0 +1,112 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { MaybePromise } from "./utils";
+import type { ProcedureInputs } from "./procedure";
+
+
+export type ProcedureType = "mutation" | "query";
+
+
+export interface ProcedureDeclaration<
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1,
+  T
+> {
+  input: InputSchema;
+  output: OutputSchema;
+  type: T;
+}
+
+
+export type ProcedureMap = { [p: string]: ProcedureDeclaration<StandardSchemaV1, StandardSchemaV1, ProcedureType> };
+
+
+export interface ChannelDeclaration<
+  ClientMessageSchema extends StandardSchemaV1,
+  ServerMessageSchema extends StandardSchemaV1,
+  ConnectionRequestSchema extends StandardSchemaV1,
+  ConnectionContextSchema extends StandardSchemaV1,
+  Params extends string[],
+> {
+  clientMessage: ClientMessageSchema,
+  serverMessage: ServerMessageSchema,
+  connectionRequest: ConnectionRequestSchema,
+  connectionContext: ConnectionContextSchema,
+  params: Params,
+}
+
+
+export type ChannelMap = {
+  [channel: string]: ChannelDeclaration<
+    StandardSchemaV1,
+    StandardSchemaV1,
+    StandardSchemaV1,
+    StandardSchemaV1,
+    string[]
+  >
+}
+
+
+export interface Covenant<
+  P extends ProcedureMap,
+  C extends ChannelMap,
+> {
+  procedures: P,
+  channels: C,
+}
+
+export function declareCovenant<
+  P extends ProcedureMap,
+  C extends ChannelMap,
+>(covenant: Covenant<P, C>): Covenant<P, C> {
+  return covenant;
+}
+
+export function mutation<
+  Inputs extends StandardSchemaV1,
+  Outputs extends StandardSchemaV1,
+>({ input, output }: {
+  input: Inputs,
+  output: Outputs,
+}): ProcedureDeclaration<Inputs, Outputs, "mutation"> {
+  return {
+    type: "mutation",
+    input,
+    output,
+  }
+}
+
+export function query<
+  Inputs extends StandardSchemaV1,
+  Outputs extends StandardSchemaV1,
+>({ input, output }: {
+  input: Inputs,
+  output: Outputs,
+}): ProcedureDeclaration<Inputs, Outputs, "query"> {
+  return {
+    type: "query",
+    input,
+    output,
+  }
+}
+
+
+// helper function to get better autocomplete
+export function channel<
+  ClientMessageSchema extends StandardSchemaV1,
+  ServerMessageSchema extends StandardSchemaV1,
+  ConnectionRequestSchema extends StandardSchemaV1,
+  ConnectionContextSchema extends StandardSchemaV1,
+  Params extends string[],
+>(c: {
+  clientMessage: ClientMessageSchema,
+  serverMessage: ServerMessageSchema,
+  connectionRequest: ConnectionRequestSchema,
+  connectionContext: ConnectionContextSchema,
+  params: Params,
+}) {
+  return c;
+}
+
+
+export type ContextGenerator<Context extends StandardSchemaV1> = 
+  (i: ProcedureInputs<unknown, undefined, undefined>) => MaybePromise<StandardSchemaV1.InferOutput<Context>>

package/lib/interfaces.ts

@@ -0,0 +1,28 @@
+import type { MaybePromise } from "../utils";
+import type { ChannelConnectionPayload, ChannelConnectionRequest, ChannelConnectionResponse, ChannelError, ServerMessage, ServerMessageWithContext } from "../channel";
+import type { ProcedureRequestBody, ProcedureResponse } from "../procedure";
+import type { SidekickIncomingMessage, SidekickOutgoingMessage } from "../sidekick/protocol";
+
+
+export interface ClientToServerConnection {
+  sendConnectionRequest(request: ChannelConnectionRequest): Promise<ChannelConnectionResponse>;
+  runProcedure(request: ProcedureRequestBody): Promise<ProcedureResponse>;
+}
+
+
+export interface ClientToSidekickConnection {
+  sendMessage(message: SidekickIncomingMessage): void;
+  onMessage(handler: (m: SidekickOutgoingMessage) => MaybePromise<void>): () => void;
+}
+
+
+export interface ServerToSidekickConnection {
+  addConnection(payload: ChannelConnectionPayload): Promise<Error | null>;
+  update(resources: string[]): Promise<Error | null>;
+  postMessage(message: ServerMessage): Promise<Error | null>;
+}
+
+
+export interface SidekickToServerConnection {
+  sendMessage(message: ServerMessageWithContext): Promise<ChannelError | null>;
+}

package/lib/logger.ts

@@ -0,0 +1,18 @@
+// Logger interface for type safety in core
+// Implementation lives in @covenant-rpc/server
+
+export type LoggerLevel = "info" | "error" | "warn" | "slient" | "debug";
+export type Prefix = string | (() => string);
+
+export interface Logger {
+  prefixes: Prefix[];
+  level: LoggerLevel;
+  sublogger(prefix: Prefix): Logger;
+  pushPrefix(prefix: Prefix): Logger;
+  clone(): Logger;
+  debug(text: string): void;
+  info(text: string): void;
+  error(text: string): void;
+  warn(text: string): void;
+  fatal(text: string): never;
+}

package/lib/procedure.ts

@@ -0,0 +1,105 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { ProcedureDeclaration, ProcedureType } from ".";
+import type { MaybePromise } from "./utils";
+import { v } from "./validation";
+import type { Logger } from "./logger";
+
+export interface ProcedureRequest {
+  headers: Headers;
+  input: unknown;
+  url: string;
+  procedure: string;
+  path: string;
+  req: Request;
+}
+
+export interface ProcedureInputs<Inputs, Context, Derivation> {
+  inputs: Inputs,
+  ctx: Context,
+  derived: Derivation,
+  request: ProcedureRequest,
+  logger: Logger,
+  setHeader: (name: string, value: string) => void;
+  deleteHeader: (name: string) => void;
+  error: (message: string, code: number) => never;
+}
+
+export interface ResourceInputs<Inputs, Context, Outputs> {
+  inputs: Inputs,
+  logger: Logger,
+  ctx: Context,
+  outputs: Outputs,
+}
+
+export type ProcedureDefinition<T, Context, Derivation> = T extends ProcedureDeclaration<
+  infer InputSchema,
+  infer OutputSchema,
+  ProcedureType> ? {
+    procedure: (i: ProcedureInputs<
+      StandardSchemaV1.InferOutput<InputSchema>,
+      Context,
+      Derivation
+    >) => MaybePromise<StandardSchemaV1.InferOutput<OutputSchema>>
+    resources: (i: ResourceInputs<
+      StandardSchemaV1.InferOutput<InputSchema>,
+      Context,
+      StandardSchemaV1.InferOutput<OutputSchema>
+    >) => MaybePromise<string[]>
+  } : never
+
+
+export const procedureErrorSchema = v.obj({
+  message: v.string(),
+  code: v.number(),
+});
+
+export type ProcedureError = v.Infer<typeof procedureErrorSchema>;
+
+
+export const procedureResponseSchema = v.union(
+  v.obj({
+    status: v.literal("OK"),
+    data: v.unknown(),
+    resources: v.array(v.string()),
+  }),
+  v.obj({
+    status: v.literal("ERR"),
+    error: procedureErrorSchema,
+  }),
+);
+
+export type ProcedureResponse = v.Infer<typeof procedureResponseSchema>;
+
+export const procedureRequestBodySchema = v.obj({
+  procedure: v.string(),
+  inputs: v.unknown(),
+});
+
+export type ProcedureRequestBody = v.Infer<typeof procedureRequestBodySchema>;
+
+
+export type InferProcedureInputs<P> = P extends ProcedureDeclaration<
+  infer InputSchema,
+  any,
+  any
+> ? StandardSchemaV1.InferInput<InputSchema> : never;
+
+
+export type InferProcedureOutputs<P> = P extends ProcedureDeclaration<
+  any,
+  infer OutputSchema,
+  any
+> ? StandardSchemaV1.InferOutput<OutputSchema> : never
+
+
+export type InferProcedureResult<P> = {
+  success: true,
+  data: InferProcedureOutputs<P>,
+  resources: string[]
+  error: null,
+} | {
+  success: false,
+  error: ProcedureError,
+  data: null,
+  resources: null,
+}

package/lib/sidekick/protocol.ts

@@ -0,0 +1,104 @@
+import { channelErrorSchema } from "../channel";
+import { v } from "../validation";
+
+
+
+// tokens are given to the server and the sidekick at the same time
+export const subscribeMessageSchema = v.obj({
+  type: v.literal("subscribe"),
+  token: v.string(),
+});
+export type SubscribeMessage = v.Infer<typeof subscribeMessageSchema>;
+
+export const unsubscribeMessageSchema = v.obj({
+  type: v.literal("unsubscribe"),
+  token: v.string(),
+});
+export type UnsubscribeMessage = v.Infer<typeof unsubscribeMessageSchema>;
+
+export const sendMessageSchema = v.obj({
+  type: v.literal("send"),
+  token: v.string(),
+  channel: v.string(),
+  params: v.record(v.string(), v.string()),
+  data: v.unknown(),
+});
+export type SendMessage = v.Infer<typeof sendMessageSchema>;
+
+export const listenMessageSchema = v.obj({
+  type: v.literal("listen"),
+  resources: v.array(v.string()),
+});
+export type ListenMessage = v.Infer<typeof listenMessageSchema>;
+
+export const unlistenMessageSchema = v.obj({
+  type: v.literal("unlisten"),
+  resources: v.array(v.string()),
+});
+export type UnlistenMessage = v.Infer<typeof unlistenMessageSchema>;
+
+export const sidekickIncomingMessageSchema = v.union(
+  subscribeMessageSchema,
+  unsubscribeMessageSchema,
+  sendMessageSchema,
+  listenMessageSchema,
+  unlistenMessageSchema,
+);
+export type SidekickIncomingMessage = v.Infer<typeof sidekickIncomingMessageSchema>;
+
+
+export const sidekickOutgoingMessageSchema = v.union(
+  v.obj({
+    type: v.literal("error"),
+    error: channelErrorSchema,
+  }),
+  v.obj({
+    type: v.literal("message"),
+    channel: v.string(),
+    params: v.record(v.string(), v.string()),
+    data: v.unknown(),
+  }),
+  v.obj({
+    type: v.literal("updated"),
+    resource: v.string(),
+  }),
+  v.obj({
+    type: v.literal("listening"),
+    resources: v.array(v.string()),
+  }),
+  v.obj({
+    type: v.literal("unlistening"),
+    resources: v.array(v.string()),
+  }),
+  v.obj({
+    type: v.literal("subscribed"),
+    channel: v.string(),
+    params: v.record(v.string(), v.string()),
+  }),
+  v.obj({
+    type: v.literal("unsubscribed"),
+    channel: v.string(),
+    params: v.record(v.string(), v.string()),
+  }),
+  v.obj({
+    type: v.literal("listening"),
+    channel: v.string(),
+    params: v.record(v.string(), v.string()),
+  }),
+)
+
+export type SidekickOutgoingMessage = v.Infer<typeof sidekickOutgoingMessageSchema>;
+
+
+export function getChannelTopicName(channel: string, params: Record<string, string>) {
+  const map = Object.keys(params).map(k => `${k}:${params[k]}`).join(",");
+  return `channel:${channel}/${map}`
+}
+
+export function getResourceTopicName(resource: string) {
+  return `resource:${resource}`;
+}
+
+export function getMapId(wsId: string, topic: string) {
+  return `${wsId}@${topic}`;
+}

package/lib/utils.ts

@@ -0,0 +1,87 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+export type MaybePromise<T> = T | Promise<T>;
+export type Flatten<T> = { [k in keyof T]: T[k] } & {};
+export type ArrayToMap<T extends readonly string[]> = { [k in T[number]]: string };
+
+
+
+export type Result<T> = {
+  success: true;
+  data: T;
+  error: null;
+} | {
+  success: false;
+  data: null;
+  error: Error
+}
+
+export type AsyncResult<T> = Promise<Result<T>>;
+
+
+export function ok<T>(t: T): Result<T> {
+  return {
+    data: t,
+    success: true,
+    error: null,
+  }
+}
+
+export function err(error: Error): Result<any> {
+  return {
+    data: null,
+    success: false,
+    error,
+  }
+}
+
+export function issuesToString(issues: readonly StandardSchemaV1.Issue[]): string {
+  const strs: string[] = []
+
+  for (const issue of issues) {
+    strs.push(`${issue.path}: ${issue.message}`);
+  }
+
+
+  return strs.join(", ");
+}
+
+
+
+export type PubsubListener<T> = (t: T) => MaybePromise<void>;
+
+export class MultiTopicPubsub<T> {
+  private listenerMap: Map<string, PubsubListener<T>[]> = new Map();
+
+  subscribe(topic: string, listener: PubsubListener<T>) {
+    if (this.listenerMap.has(topic)) {
+      const newListeners = [...this.listenerMap.get(topic)!, listener];
+      this.listenerMap.set(topic, newListeners);
+    } else {
+      this.listenerMap.set(topic, [listener]);
+    }
+  }
+
+  unsubscribe(topic: string, listener: PubsubListener<T>) {
+    if (this.listenerMap.has(topic)) {
+      const listeners = this.listenerMap.get(topic)!;
+      this.listenerMap.set(topic, listeners.filter(l => l !== listener));
+    }
+  }
+
+  async publish(topic: string, data: T) {
+    const listeners = this.listenerMap.get(topic) ?? [];
+
+    const promises = listeners.map(l => l(data));
+    await Promise.all(promises);
+  }
+}
+
+
+
+export function isPromise(obj: unknown): obj is Promise<unknown> {
+  return obj != null &&
+    typeof obj === "object" &&
+    typeof (obj as any).then === "function";
+}
+

package/lib/validation.ts

@@ -0,0 +1,99 @@
+// Covenant cannot have any dependencies, so I have to make a very tiny validation library for parsing requests. This does not implement standard schema, and should not be used
+// outside of covenant code. If you are doing so, you are wrong
+export namespace v {
+  export type Validator<T> = (o: unknown) => o is T;
+  export type Infer<K> = K extends Validator<infer T> ? T : never;
+
+  export const bool: () => Validator<boolean> = () => (o: unknown) => typeof o === "boolean";
+  export const number: () => Validator<number> = () => (o: unknown) => typeof o === "number"
+  export const string: () => Validator<string> = () => (o: unknown) => typeof o === "string";
+  export const unknown: () => Validator<unknown> = () => (o: unknown): o is unknown => true;
+
+  export function optional<T>(validator: Validator<T>): Validator<T | undefined> {
+    return (o: unknown) => validator(o) || o === undefined;
+  }
+  export function nullable<T>(validator: Validator<T>): Validator<T | null> {
+    return (o: unknown) => validator(o) || o === null;
+  }
+
+  export function union<T extends readonly Validator<any>[]>(...validators: T): Validator<Infer<T[number]>> {
+    return (o: unknown): o is Infer<T[number]> => {
+      return validators.some(validator => validator(o));
+    };
+  }
+
+  export function literal<T extends string | number | boolean | null | undefined>(value: T): Validator<T> {
+    return (o: unknown): o is T => o === value;
+  }
+
+  export function obj<T extends Record<string, Validator<any>>>(obj: T): Validator<{ [K in keyof T]: Infer<T[K]> }> {
+    return (o: unknown): o is { [K in keyof T]: Infer<T[K]> } => {
+      if (typeof o !== "object" || o === null || o === undefined) {
+        return false;
+      }
+      
+      const target = o as Record<string, unknown>;
+
+      for (const key of Object.keys(obj)) {
+        const validator = obj[key]!;
+        const valid = validator(target[key]);
+        if (!valid) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  export function parse<T>(object: unknown, validator: Validator<T>): T {
+    const valid = validator(object);
+
+    if (!valid) {
+      throw new Error("Validation failed!");
+    }
+
+    return object;
+  }
+
+  export function parseSafe<T>(object: unknown, validator: Validator<T>): T | null {
+    const valid = validator(object);
+
+    if (!valid) {
+      return null;
+    }
+
+    return object;
+  }
+
+  export function array<T>(elementValidator: Validator<T>): Validator<T[]> {
+    return (o: unknown): o is T[] => {
+      if (!Array.isArray(o)) {
+        return false;
+      }
+      return o.every(element => elementValidator(element));
+    };
+  }
+
+  export function record<K extends string | number | symbol, V>(
+    keyValidator: Validator<K>,
+    valueValidator: Validator<V>
+  ): Validator<Record<K, V>> {
+    return (o: unknown): o is Record<K, V> => {
+      if (typeof o !== "object" || o === null || o === undefined) {
+        return false;
+      }
+      
+      const target = o as Record<string | number | symbol, unknown>;
+      
+      for (const [key, value] of Object.entries(target)) {
+        if (!keyValidator(key) || !valueValidator(value)) {
+          return false;
+        }
+      }
+      
+      return true;
+    };
+  }
+}
+

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@covenant-rpc/core",
+  "module": "lib/index.ts",
+  "version": "0.1.3",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./lib/index.ts",
+    "./*": "./lib/*.ts"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0"
+  }
+}