@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.13

package/src/config/Actors.ts

@@ -1,9 +0,0 @@
-import z from 'zod'
-
-import { ActorConfigZod } from './Actor.ts'
-
-/** ActorsConfigZod constant. */
-export const ActorsConfigZod = z.array(ActorConfigZod.loose()).describe('Actor-specific configurations that override the base configuration when the actor is running').default([])
-
-/** ActorsConfig type. */
-export type ActorsConfig = z.infer<typeof ActorsConfigZod>

package/src/config/Base.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod'
-
-import { ChainConfigZod } from './Chain.ts'
-import { DataLakeConfigZod } from './DataLake/index.ts'
-import { EvmConfigZod } from './Evm.ts'
-import { LogConfigZod } from './Log.ts'
-import { ProvidersConfigZod } from './Providers.ts'
-import { RemoteConfigZod } from './Remote.ts'
-import { StorageConfigZod } from './storage/index.ts'
-import { TelemetryConfigZod } from './Telemetry.ts'
-import { ValidationConfigZod } from './Validation.ts'
-
-/** BaseConfigZod constant. */
-export const BaseConfigZod = z.object({
-  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe('Configuration for the chain'),
-  dataLake: DataLakeConfigZod.optional().describe('Configuration for data lakes'),
-  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe('Configuration for EVM-backed services'),
-  log: LogConfigZod.default(LogConfigZod.parse({})).describe('Configuration for logging'),
-  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe('Configuration for providers'),
-  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe('Configuration for remote services'),
-  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe('Configuration for the storage'),
-  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe('Configuration for telemetry'),
-  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe('Configuration for validation'),
-})
-
-/** BaseConfig type. */
-export type BaseConfig = z.infer<typeof BaseConfigZod>

package/src/config/Chain.ts

@@ -1,23 +0,0 @@
-import { AddressZod, HexZod } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-/** ChainConfigZod constant. */
-export const ChainConfigZod = z.object({
-  id: HexZod.optional()
-    .register(globalRegistry, {
-      description:
-      'The unique identifier for the chain. Should be the staking contract address for contract-backed chains.',
-      title: 'chain.id',
-      type: 'string',
-    }),
-  genesisRewardAddress: AddressZod.optional()
-    .register(globalRegistry, {
-      description:
-      'Address to send the initial genesis rewards to, if a new chain is being created.',
-      title: 'chain.genesisRewardAddress',
-      type: 'Address',
-    }),
-})
-
-/** ChainConfig type. */
-export type ChainConfig = z.infer<typeof ChainConfigZod>

package/src/config/Config.ts

@@ -1,24 +0,0 @@
-import type z from 'zod'
-
-import { ActorConfigZod } from './Actor.ts'
-import { ActorsConfigZod } from './Actors.ts'
-import { BaseConfigZod } from './Base.ts'
-import type { DeepPartial } from './DeepPartial.ts'
-
-/** ConfigZod constant. */
-export const ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe('The complete configuration for the protocol, including global settings and actor-specific overrides')
-
-/** Config type. */
-export type Config = z.infer<typeof ConfigZod>
-
-/** ResolveConfig helper function. */
-export function resolveConfig(
-  config: DeepPartial<Config>,
-) {
-  const parsedConfig = ConfigZod.parse(config)
-  const { actors, ...rootConfig } = parsedConfig
-  parsedConfig.actors = actors.map((actorConfig) => {
-    return ActorConfigZod.loose().parse({ ...rootConfig, ...actorConfig })
-  })
-  return parsedConfig
-}

package/src/config/DataLake/DataLake.ts

@@ -1,12 +0,0 @@
-import { z } from 'zod'
-
-import { type RestDataLakeConfig, RestDataLakeConfigZod } from './RestDataLakeConfig.ts'
-import { type RouterDataLakeConfig, RouterDataLakeConfigZod } from './RouterDataLakeConfig.ts'
-
-/** DataLakeConfig type. */
-export type DataLakeConfig = RestDataLakeConfig | RouterDataLakeConfig
-
-// z.lazy handles the circular reference between DataLakeConfigZod and RouterDataLakeZod
-/** DataLakeConfigZod constant. */
-export const DataLakeConfigZod: z.ZodType<DataLakeConfig> = z.lazy(() =>
-  z.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe('Configuration for a data lake')

package/src/config/DataLake/DataLakeRemoteConfig.ts

@@ -1,11 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-/** DataLakeDriverConfigBaseZod constant. */
-export const DataLakeDriverConfigBaseZod = z.object({
-  driver: z.string().register(globalRegistry, {
-    description: 'Driver for the data lake',
-    type: 'string',
-  }),
-}).describe('Base configuration for a data lake driver')
-/** DataLakeDriverConfigBase type. */
-export type DataLakeDriverConfigBase = z.infer<typeof DataLakeDriverConfigBaseZod>

package/src/config/DataLake/RestDataLakeConfig.ts

@@ -1,18 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { DataLakeDriverConfigBaseZod } from './DataLakeRemoteConfig.ts'
-
-/** RestDataLakeConfigZod constant. */
-export const RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z.literal('rest').register(globalRegistry, {
-    description: 'Driver for the REST data lake',
-    type: 'string',
-  }),
-  url: z.string().register(globalRegistry, {
-    description: 'URL for the REST data lake',
-    type: 'string',
-  }),
-}).describe('Configuration for the REST data lake driver')
-
-/** RestDataLakeConfig type. */
-export type RestDataLakeConfig = z.infer<typeof RestDataLakeConfigZod>

package/src/config/DataLake/RouterDataLakeConfig.ts

@@ -1,22 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import type { DataLakeConfig } from './DataLake.ts'
-import { DataLakeConfigZod } from './DataLake.ts'
-
-/** Configuration for RouterDataLake. */
-export interface RouterDataLakeConfig {
-  children: DataLakeConfig[]
-  driver: 'router'
-}
-
-/** RouterDataLakeConfigZod constant. */
-export const RouterDataLakeConfigZod: z.ZodType<RouterDataLakeConfig> = z.object({
-  driver: z.literal('router').register(globalRegistry, {
-    description: 'Driver for the router data lake',
-    type: 'string',
-  }),
-  children: z.array(z.lazy(() => DataLakeConfigZod)).register(globalRegistry, {
-    description: 'Child data lake drivers',
-    type: 'array',
-  }),
-}).describe('Configuration for the router data lake driver')

package/src/config/DataLake/index.ts

@@ -1,4 +0,0 @@
-export * from './DataLake.ts'
-export * from './DataLakeRemoteConfig.ts'
-export * from './RestDataLakeConfig.ts'
-export * from './RouterDataLakeConfig.ts'

package/src/config/DeepPartial.ts

@@ -1,4 +0,0 @@
-/** DeepPartial type. */
-export type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
-}

package/src/config/Evm.ts

@@ -1,38 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-/** EvmInfuraConfigZod constant. */
-export const EvmInfuraConfigZod = z.object({
-  projectId: z.string().optional().register(globalRegistry, {
-    description: 'Infura project ID',
-    title: 'evm.infura.projectId',
-    type: 'string',
-  }),
-  projectSecret: z.string().optional().register(globalRegistry, {
-    description: 'Infura project secret',
-    title: 'evm.infura.projectSecret',
-    type: 'string',
-  }),
-})
-
-/** EvmJsonRpcConfigZod constant. */
-export const EvmJsonRpcConfigZod = z.object({
-  url: z.url().optional().register(globalRegistry, {
-    description: 'JSON-RPC URL',
-    title: 'evm.jsonRpc.url',
-    type: 'string',
-  }),
-})
-
-/** EvmConfigZod constant. */
-export const EvmConfigZod = z.object({
-  chainId: z.string().optional().register(globalRegistry, {
-    description: 'EVM chain ID',
-    title: 'evm.chainId',
-    type: 'string',
-  }),
-  infura: EvmInfuraConfigZod.optional().describe('Infura Provider configuration'),
-  jsonRpc: EvmJsonRpcConfigZod.optional().describe('JSON-RPC Provider configuration'),
-})
-
-/** EvmConfig type. */
-export type EvmConfig = z.infer<typeof EvmConfigZod>

package/src/config/HostActor.ts

@@ -1,32 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-import { ActorConfigZod } from './Actor.ts'
-
-/** HostActorConfigZod constant. */
-export const HostActorConfigZod = ActorConfigZod.extend({
-  host: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the Actor',
-    title: 'host',
-    type: 'string',
-  }),
-  port: z.coerce.number().default(8080).register(globalRegistry, {
-    default: 8080,
-    description: 'Port for the Actor',
-    title: 'port',
-    type: 'number',
-  }),
-})
-
-/** HostActorConfig type. */
-export type HostActorConfig = z.infer<typeof HostActorConfigZod>
-
-/** Type guard that checks if a value is a valid HostActorConfig. */
-export const isHostActorConfig = zodIsFactory(HostActorConfigZod)
-/** Converts a value to HostActorConfig, throwing if invalid. */
-export const asHostActorConfig = zodAsFactory(HostActorConfigZod, 'asHostActorConfig')
-/** toHostActorConfig constant. */
-export const toHostActorConfig = zodToFactory(HostActorConfigZod, 'toHostActorConfig')

package/src/config/Log.ts

@@ -1,25 +0,0 @@
-import type { LogLevelKey } from '@xylabs/sdk-js'
-import { LogLevel } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-const LogLevelNames = Object.keys(LogLevel) as [LogLevelKey]
-
-/** LogConfigZod constant. */
-export const LogConfigZod = z.object({
-  logLevel: z.enum(LogLevelNames).default('info').register(globalRegistry, {
-    choices: LogLevelNames,
-    default: 'info',
-    description: 'Desired process verbosity',
-    title: 'logLevel',
-    type: 'string',
-  }),
-  silent: z.boolean().default(false).register(globalRegistry, {
-    default: false,
-    description: 'Whether to run in silent mode',
-    title: 'silent',
-    type: 'boolean',
-  }),
-})
-
-/** LogConfig type. */
-export type LogConfig = z.infer<typeof LogConfigZod>

package/src/config/Provider.ts

@@ -1,20 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-/** ProviderConfigZod constant. */
-export const ProviderConfigZod = z.object({
-  moniker: z.string(),
-  labels: z.array(z.string()).optional(),
-}).describe('Configuration for a Provider')
-
-/** ProviderConfig type. */
-export type ProviderConfig = z.infer<typeof ProviderConfigZod>
-
-/** Type guard that checks if a value is a valid ProviderConfig. */
-export const isProviderConfig = zodIsFactory(ProviderConfigZod)
-/** Converts a value to ProviderConfig, throwing if invalid. */
-export const asProviderConfig = zodAsFactory(ProviderConfigZod, 'asProviderConfig')
-/** toProviderConfig constant. */
-export const toProviderConfig = zodToFactory(ProviderConfigZod, 'toProviderConfig')

package/src/config/Providers.ts

@@ -1,9 +0,0 @@
-import z from 'zod'
-
-import { ProviderConfigZod } from './Provider.ts'
-
-/** ProvidersConfigZod constant. */
-export const ProvidersConfigZod = z.array(ProviderConfigZod.loose()).describe('Configuration for providers').default([])
-
-/** ProvidersConfig type. */
-export type ProvidersConfig = z.infer<typeof ProvidersConfigZod>

package/src/config/Remote.ts

@@ -1,59 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-/** RpcRemoteConfigBaseZod constant. */
-export const RpcRemoteConfigBaseZod = z.object({
-  protocol: z.string('http').register(globalRegistry, {
-    description: 'Protocol for the RPC connection',
-    type: 'string',
-  }),
-}).describe('Base configuration for the remote RPC')
-
-/** RpcRemoteConfigBase type. */
-export type RpcRemoteConfigBase = z.infer<typeof RpcRemoteConfigBaseZod>
-
-/** HttpRpcRemoteConfigZod constant. */
-export const HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z.string('http').register(globalRegistry, {
-    description: 'Protocol for the RPC connection',
-    type: 'string',
-  }).default('http'),
-  url: z.string().register(globalRegistry, {
-    description: 'URL for the Chain RPC API',
-    type: 'string',
-  }),
-}).describe('Configuration for the remote RPC using Http')
-
-/** HttpRpcRemoteConfig type. */
-export type HttpRpcRemoteConfig = z.infer<typeof HttpRpcRemoteConfigZod>
-
-/** PostMessageRpcRemoteConfigZod constant. */
-export const PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z.string().register(globalRegistry, {
-    description: 'Protocol for the RPC connection',
-    type: 'string',
-  }).default('postMessage'),
-  networkId: z.string().register(globalRegistry, {
-    description: 'Network ID to use for the postMessage RPC connection',
-    type: 'string',
-  }),
-  sessionId: z.string().register(globalRegistry, {
-    description: 'Session ID to use for the postMessage RPC connection',
-    type: 'string',
-  }),
-}).describe('Configuration for the remote RPC using postMessage')
-
-/** PostMessageRpcRemoteConfig type. */
-export type PostMessageRpcRemoteConfig = z.infer<typeof PostMessageRpcRemoteConfigZod>
-
-/** RpcRemoteConfigZod constant. */
-export const RpcRemoteConfigZod = z.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod])
-  .describe('Configuration for a remote RPC connection, either Http or postMessage')
-
-/** RpcRemoteConfig type. */
-export type RpcRemoteConfig = z.infer<typeof RpcRemoteConfigZod>
-
-/** RemoteConfigZod constant. */
-export const RemoteConfigZod = z.object({ rpc: RpcRemoteConfigZod.optional() }).describe('Configuration for remote connections, including RPC')
-
-/** RemoteConfig type. */
-export type RemoteConfig = z.infer<typeof RemoteConfigZod>

package/src/config/Telemetry.ts

@@ -1,49 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-/** DefaultMetricsScrapePorts constant. */
-export const DefaultMetricsScrapePorts = {
-  api: 9465,
-  bridge: 9468,
-  mempool: 9466,
-  producer: 9464,
-  rewardRedemptionApi: 9467,
-}
-
-/** MetricsScrapeConfigZod constant. */
-export const MetricsScrapeConfigZod = z.object({
-  path: z.string().default('/metrics').register(globalRegistry, {
-    default: '/metrics',
-    description: 'Path for the metrics scrape endpoint',
-    title: 'telemetry.metrics.scrape.path',
-    type: 'string',
-  }),
-  port: z.coerce.number().int().positive().optional().register(globalRegistry, {
-    description: 'Port for the metrics scrape endpoint',
-    title: 'telemetry.metrics.scrape.port',
-    type: 'number',
-  }),
-}).describe('Metrics scrape configuration')
-
-/** MetricsConfigZod constant. */
-export const MetricsConfigZod = z.object({ scrape: MetricsScrapeConfigZod }).describe('Metrics configuration options')
-
-/** OpenTelemetryConfigZod constant. */
-export const OpenTelemetryConfigZod = z.object({
-  // OpenTelemetry options
-  otlpEndpoint: z.url().optional().register(globalRegistry, {
-    description: 'OTLP endpoint for exporting telemetry data',
-    title: 'telemetry.otel.otlpEndpoint',
-    type: 'string',
-  }),
-})
-
-/** TelemetryConfigZod constant. */
-export const TelemetryConfigZod = z.object({
-  // Metrics configuration
-  metrics: MetricsConfigZod.optional().describe('Metrics configuration'),
-  // OpenTelemetry configuration
-  otel: OpenTelemetryConfigZod.optional().describe('OpenTelemetry configuration'),
-}).describe('Telemetry configuration options')
-
-/** TelemetryConfig type. */
-export type TelemetryConfig = z.infer<typeof TelemetryConfigZod>

package/src/config/UsageMeta.ts

@@ -1,46 +0,0 @@
-import { z } from 'zod'
-
-const DescriptionSchema = z.string()
-const TitleSchema = z.string()
-
-/** Schema identifier for JSONMeta payloads. */
-export const JSONSchemaMetaSchema = z
-  .object({
-    id: z.string().optional(),
-    title: TitleSchema.optional(),
-    description: DescriptionSchema.optional(),
-    deprecated: z.boolean().optional(),
-  })
-  .catchall(z.unknown()) // allow arbitrary extra keys
-
-/** Schema identifier for GlobalMeta payloads. */
-export const GlobalMetaSchema = JSONSchemaMetaSchema.extend({})
-
-const ChoicesSchema = z
-  .array(z.union([z.string(), z.number(), z.literal(true), z.undefined()]))
-  .readonly()
-
-/** Schema identifier for UsageMeta payloads. */
-export const UsageMetaSchema = GlobalMetaSchema.extend({
-  choices: ChoicesSchema.optional(),
-  default: z.unknown().optional(),
-  description: DescriptionSchema,
-  group: z.string().optional(),
-  hidden: z.boolean().optional(),
-  title: TitleSchema,
-  type: z.union([
-    z.literal('array'),
-    z.literal('count'),
-    z.literal('boolean'),
-    z.literal('number'),
-    z.literal('string'),
-  ]),
-})
-
-/** UsageMeta type. */
-export type UsageMeta = z.infer<typeof UsageMetaSchema>
-
-/** Type guard that checks if a value is a valid UsageMeta. */
-export function isUsageMeta(v: unknown): v is UsageMeta {
-  return UsageMetaSchema.safeParse(v).success
-}

package/src/config/Validation.ts

@@ -1,29 +0,0 @@
-import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-/** ValidationConfigZod constant. */
-export const ValidationConfigZod = z.object({
-  allowedRewardRedeemers: z.preprocess((val) => {
-    if (typeof val === 'string') {
-      return val.split(',').map(s => asAddress(s.trim()))
-    }
-    return val
-  }, z.array(AddressZod).optional().register(globalRegistry, {
-    description: 'List of allowed reward redeemer addresses, if undefined anyone can participate',
-    title: 'allowedRewardRedeemers',
-    type: 'array',
-  })),
-  allowedRewardEscrowAccountSigners: z.preprocess((val) => {
-    if (typeof val === 'string') {
-      return val.split(',').map(s => asAddress(s.trim()))
-    }
-    return val
-  }, z.array(AddressZod).optional().register(globalRegistry, {
-    description: 'List of allowed reward escrow account signer addresses, if undefined anyone can participate',
-    title: 'allowedRewardEscrowAccountSigners',
-    type: 'array',
-  })),
-})
-
-/** ValidationConfig type. */
-export type ValidationConfig = z.infer<typeof ValidationConfigZod>

package/src/config/index.ts

@@ -1,12 +0,0 @@
-export * from './Actor.ts'
-export * from './Actors.ts'
-export * from './Base.ts'
-export * from './Config.ts'
-export * from './DataLake/index.ts'
-export * from './HostActor.ts'
-export * from './Provider.ts'
-export * from './Providers.ts'
-export * from './Remote.ts'
-export { hasMongoConfig } from './storage/index.ts'
-export { DefaultMetricsScrapePorts } from './Telemetry.ts'
-export * from './UsageMeta.ts'

package/src/config/storage/Storage.ts

@@ -1,16 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { MongoConfigZod } from './driver/index.ts'
-
-/** StorageConfigZod constant. */
-export const StorageConfigZod = z.object({
-  mongo: MongoConfigZod.optional().describe('Configuration for the MongoD storage driver'),
-  root: z.string().optional().register(globalRegistry, {
-    description: 'Root directory for local storage',
-    title: 'storage.root',
-    type: 'string',
-  }),
-}).describe('Storage configuration options')
-
-/** StorageConfig type. */
-export type StorageConfig = z.infer<typeof StorageConfigZod>

package/src/config/storage/driver/Mongo.ts

@@ -1,53 +0,0 @@
-import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-/**
- * Checks if the provided MongoDB configuration contains all necessary fields
- * for establishing a connection.
- * @param config MongoDB configuration object
- * @returns True if the configuration contains all necessary fields for
- * establishing a connection
- */
-export const hasMongoConfig = (config?: MongoConfig): config is Required<MongoConfig> => {
-  if (isUndefined(config)) return false
-  return (
-    isDefined(config.connectionString)
-    && isDefined(config.database)
-    && isDefined(config.domain)
-    && isDefined(config.password)
-    && isDefined(config.username)
-  )
-}
-
-/** MongoConfigZod constant. */
-export const MongoConfigZod = z.object({
-  // TODO: Create from other arguments
-  connectionString: z.string().nonempty().optional().register(globalRegistry, {
-    description: 'MongoDB connection string',
-    title: 'storage.mongo.connectionString',
-    type: 'string',
-  }),
-  database: z.string().nonempty().optional().register(globalRegistry, {
-    description: 'MongoDB database name',
-    title: 'storage.mongo.database',
-    type: 'string',
-  }),
-  domain: z.string().nonempty().optional().register(globalRegistry, {
-    description: 'MongoDB domain',
-    title: 'storage.mongo.domain',
-    type: 'string',
-  }),
-  password: z.string().nonempty().optional().register(globalRegistry, {
-    description: 'MongoDB password',
-    title: 'storage.mongo.password',
-    type: 'string',
-  }),
-  username: z.string().nonempty().optional().register(globalRegistry, {
-    description: 'MongoDB username',
-    title: 'storage.mongo.username',
-    type: 'string',
-  }),
-})
-
-/** MongoConfig type. */
-export type MongoConfig = z.infer<typeof MongoConfigZod>

package/src/config/storage/driver/index.ts

@@ -1 +0,0 @@
-export * from './Mongo.ts'

package/src/config/storage/index.ts

@@ -1,2 +0,0 @@
-export * from './driver/index.ts'
-export * from './Storage.ts'

package/src/constants.ts

@@ -1,4 +0,0 @@
-/** XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH constant. */
-export const XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH = 1_760_572_800 as const
-/** XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK constant. */
-export const XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK = 107_496 as const

package/src/context/Actor.ts

@@ -1,20 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import type { z } from 'zod'
-
-import { ActorConfigZod } from '../config/index.ts'
-import { BaseConfigContextZod } from '../model/index.ts'
-
-/** ActorConfigContext constant. */
-export const ActorConfigContext = BaseConfigContextZod.extend({ config: ActorConfigZod })
-
-/** ActorConfigContext type. */
-export type ActorConfigContext = z.infer<typeof ActorConfigContext>
-
-/** Type guard that checks if a value is a valid ActorConfigContext. */
-export const isActorConfigContext = zodIsFactory(ActorConfigContext)
-/** Converts a value to ActorConfigContext, throwing if invalid. */
-export const asActorConfigContext = zodAsFactory(ActorConfigContext, 'asActorConfigContext')
-/** toActorConfigContext constant. */
-export const toActorConfigContext = zodToFactory(ActorConfigContext, 'toActorConfigContext')

package/src/context/HostActor.ts

@@ -1,20 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import type { z } from 'zod'
-
-import { HostActorConfigZod } from '../config/index.ts'
-import { BaseConfigContextZod } from '../model/index.ts'
-
-/** HostActorConfigContext constant. */
-export const HostActorConfigContext = BaseConfigContextZod.extend({ config: HostActorConfigZod })
-
-/** HostActorConfigContext type. */
-export type HostActorConfigContext = z.infer<typeof HostActorConfigContext>
-
-/** Type guard that checks if a value is a valid HostActorConfigContext. */
-export const isHostActorConfigContext = zodIsFactory(HostActorConfigContext)
-/** Converts a value to HostActorConfigContext, throwing if invalid. */
-export const asHostActorConfigContext = zodAsFactory(HostActorConfigContext, 'asHostActorConfigContext')
-/** toHostActorConfigContext constant. */
-export const toHostActorConfigContext = zodToFactory(HostActorConfigContext, 'toHostActorConfigContext')

package/src/context/getEmptyProviderContext.ts

@@ -1,19 +0,0 @@
-import type { Config } from '../config/index.ts'
-import { ProviderFactoryLocator } from '../CreatableProvider/index.ts'
-import type { CreatableProviderContext } from '../model/index.ts'
-
-/** @deprecated use getTestProviderContext instead */
-export function getEmptyProviderContext(config: Config): CreatableProviderContext {
-  const singletons = {}
-  const caches = {}
-  const locator = new ProviderFactoryLocator({
-    config, singletons, caches, logger: console,
-  })
-  return locator.context
-}
-
-/** @deprecated Use getEmptyProviderContext instead */
-export function getEmptyContext(config: Config) {
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  return getEmptyProviderContext(config)
-}

package/src/context/index.ts

@@ -1,3 +0,0 @@
-export * from './Actor.ts'
-export * from './getEmptyProviderContext.ts'
-export * from './HostActor.ts'