@xylabs/creatable 5.0.65 → 5.0.66

package/dist/neutral/model/CreatableStatusReporter.zod.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const CreatableStatusSuccessZod: z.ZodEnum<{
+    creating: "creating";
+    created: "created";
+    starting: "starting";
+    started: "started";
+    stopping: "stopping";
+    stopped: "stopped";
+}>;
+export declare const CreatableStatusErrorZod: z.ZodEnum<{
+    error: "error";
+}>;
+export declare const CreatableStatusZod: z.ZodUnion<readonly [z.ZodEnum<{
+    creating: "creating";
+    created: "created";
+    starting: "starting";
+    started: "started";
+    stopping: "stopping";
+    stopped: "stopped";
+}>, z.ZodEnum<{
+    error: "error";
+}>]>;
+export declare const CreatableStatusReporterV2Zod: z.ZodObject<{
+    report: z.ZodUnion<readonly [z.ZodFunction<z.ZodUnion<readonly [z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        creating: "creating";
+        created: "created";
+        starting: "starting";
+        started: "started";
+        stopping: "stopping";
+        stopped: "stopped";
+    }>, z.ZodOptional<z.ZodNumber>], null>, z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        error: "error";
+    }>, z.ZodCustom<Error, Error>], null>, z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+        creating: "creating";
+        created: "created";
+        starting: "starting";
+        started: "started";
+        stopping: "stopping";
+        stopped: "stopped";
+    }>, z.ZodEnum<{
+        error: "error";
+    }>]>], null>]>, z.ZodVoid>]>;
+}, z.core.$strip>;
+//# sourceMappingURL=CreatableStatusReporter.zod.d.ts.map

package/dist/neutral/model/CreatableStatusReporter.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreatableStatusReporter.zod.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableStatusReporter.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,yBAAyB;;;;;;;EAAgF,CAAA;AAEtH,eAAO,MAAM,uBAAuB;;EAAoB,CAAA;AAExD,eAAO,MAAM,kBAAkB;;;;;;;;;IAAgE,CAAA;AAE/F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBAsBvC,CAAA"}

package/dist/neutral/model/CreatableStatusReporterV2.d.ts

@@ -0,0 +1,7 @@
+import type z from 'zod';
+import type { CreatableStatusReporterV2Zod, CreatableStatusSuccessZod, CreatableStatusZod } from './CreatableStatusReporter.zod.ts';
+export type CreatableStatusSuccessV2 = z.infer<typeof CreatableStatusSuccessZod>;
+export type CreatableStatusErrorV2 = Extract<CreatableStatusV2, 'error'>;
+export type CreatableStatusV2 = z.infer<typeof CreatableStatusZod>;
+export type CreatableStatusReporterV2 = z.infer<typeof CreatableStatusReporterV2Zod>;
+//# sourceMappingURL=CreatableStatusReporterV2.d.ts.map

package/dist/neutral/model/CreatableStatusReporterV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreatableStatusReporterV2.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableStatusReporterV2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,4BAA4B,EAAE,yBAAyB,EAAE,kBAAkB,EAC5E,MAAM,kCAAkC,CAAA;AAEzC,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAChF,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAA;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAElE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/neutral/model/index.d.ts

@@ -1,5 +1,10 @@
 export * from './CreatableInstance.ts';
+export * from './CreatableInstanceV2.ts';
+export * from './CreatableName.ts';
 export * from './CreatableParams.ts';
+export * from './CreatableParamsV2.ts';
 export * from './CreatableStatusReporter.ts';
+export * from './CreatableStatusReporter.zod.ts';
+export * from './CreatableStatusReporterV2.ts';
 export * from './Labels.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/model/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,kCAAkC,CAAA;AAChD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,aAAa,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/creatable",
-  "version": "5.0.65",
+  "version": "5.0.66",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -38,21 +38,27 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/assert": "~5.0.65",
-    "@xylabs/base": "~5.0.65",
-    "@xylabs/events": "~5.0.65",
-    "@xylabs/logger": "~5.0.65",
-    "@xylabs/promise": "~5.0.65",
-    "@xylabs/telemetry": "~5.0.65",
-    "@xylabs/typeof": "~5.0.65",
+    "@xylabs/assert": "~5.0.66",
+    "@xylabs/base": "~5.0.66",
+    "@xylabs/events": "~5.0.66",
+    "@xylabs/logger": "~5.0.66",
+    "@xylabs/promise": "~5.0.66",
+    "@xylabs/telemetry": "~5.0.66",
+    "@xylabs/typeof": "~5.0.66",
     "async-mutex": "~0.5.0"
   },
   "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
     "@xylabs/ts-scripts-yarn3": "~7.3.2",
     "@xylabs/tsconfig": "~7.3.2",
     "tslib": "~2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.18"
+    "vitest": "~4.0.18",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1",
+    "zod": "^4"
   },
   "publishConfig": {
     "access": "public"

package/src/AbstractCreatable.ts

@@ -17,8 +17,9 @@ import {
 } from './Creatable.ts'
 import { Factory } from './Factory.ts'
 import { getFunctionName, getRootFunction } from './lib/index.ts'
+import { CreatableName } from './model/CreatableName.ts'
 import type {
-  CreatableInstance, CreatableName, CreatableParams,
+  CreatableInstance, CreatableParams,
   CreatableStatus,
   Labels,
   RequiredCreatableParams,
@@ -27,6 +28,7 @@ import type {
 const AbstractCreatableConstructorKey = Symbol.for('AbstractCreatableConstructor')
 const CREATABLE_NOT_STARTED = 'Creatable not Started' as const
 
+/** @deprecated use AbstractCreatableV2 instead */
 @creatable()
 export class AbstractCreatable<TParams extends CreatableParams = CreatableParams,
   TEventData extends EventData = EventData> extends BaseEmitter<Partial<TParams & RequiredCreatableParams>, TEventData> {

package/src/AbstractCreatableV2.ts

@@ -0,0 +1,270 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseEmitterParamsV2, EventData } from '@xylabs/events'
+import { BaseEmitterV2 } from '@xylabs/events'
+import { type Logger } from '@xylabs/logger'
+import type { Promisable } from '@xylabs/promise'
+import type { SpanConfig } from '@xylabs/telemetry'
+import { spanRoot, spanRootAsync } from '@xylabs/telemetry'
+import {
+  isError, isNumber, isString,
+  isUndefined,
+} from '@xylabs/typeof'
+import { Mutex } from 'async-mutex'
+
+import type { CreatableFactoryV2, CreatableV2 } from './CreatableV2.ts'
+import { FactoryV2 } from './FactoryV2.ts'
+import { getFunctionName, getRootFunction } from './lib/index.ts'
+import type {
+  CreatableInstanceV2,
+  CreatableName, CreatableParamsV2,
+  CreatableStatusV2,
+  Labels,
+} from './model/index.ts'
+
+const AbstractCreatableConstructorKey = Symbol.for('AbstractCreatableConstructor')
+const CREATABLE_NOT_STARTED = 'Creatable not Started' as const
+
+export abstract class AbstractCreatableV2<TParams extends CreatableParamsV2 = CreatableParamsV2,
+  TEventData extends EventData = EventData> extends BaseEmitterV2<TParams, TEventData> {
+  defaultLogger?: Logger
+
+  protected _startPromise: Promisable<boolean> | undefined
+  private _status: CreatableStatusV2 | null = null
+  private _statusMutex = new Mutex()
+  private _validatedParams?: TParams & BaseEmitterParamsV2
+
+  constructor(key: unknown, params: TParams) {
+    assertEx(key === AbstractCreatableConstructorKey, () => 'AbstractCreatable should not be instantiated directly, use the static create method instead')
+    super(params)
+  }
+
+  override get context(): TParams['context'] & BaseEmitterParamsV2['context'] {
+    return this.params.context
+  }
+
+  get name(): CreatableName {
+    return this.params.name as CreatableName
+  }
+
+  override get params(): TParams & BaseEmitterParamsV2 {
+    this._validatedParams = this._validatedParams ?? this.paramsValidator(super.params)
+    return assertEx(this._validatedParams)
+  }
+
+  get startable() {
+    return this.status === 'created' || this.status === 'stopped'
+  }
+
+  get status(): CreatableStatusV2 | null {
+    return this._status
+  }
+
+  get statusReporter() {
+    return this.context.statusReporter
+  }
+
+  abstract override get className(): CreatableName
+
+  static async create<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    inParams: Partial<T['params']> = {},
+  ): Promise<T> {
+    const params = await this.paramsHandler(inParams)
+    const name = (params.name ?? this.name) as CreatableName
+    try {
+      const instance = new this(AbstractCreatableConstructorKey, params)
+      instance.setStatus('creating')
+      const initializedInstance = await this.createHandler(instance)
+      await instance.createHandler()
+      instance.setStatus('created')
+      return initializedInstance
+    } catch (ex) {
+      params.context.statusReporter?.report(name, 'error', isError(ex) ? ex : new Error(`Error creating: ${name}`))
+      params.context.logger?.error(`Error creating creatable [${name}]: ${(isError(ex) ? `${ex.message} ${ex.stack}` : ex)}`)
+      throw isError(ex) ? ex : new Error(`Error creating: ${name}`)
+    }
+  }
+
+  static createHandler<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    instance: T,
+  ): Promisable<T> {
+    return instance
+  }
+
+  static paramsHandler<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    params: Partial<T['params']> = {},
+  ): Promisable<T['params']> {
+    return { ...params } as T['params']
+  }
+
+  createHandler(): Promisable<void> {
+    assertEx(this._status === 'creating', () => `createHandler can not be called [status = ${this.status}]`)
+  }
+
+  paramsValidator(params: Partial<TParams>): TParams {
+    return { ...params, name: params.name } as TParams
+  }
+
+  span<T>(name: string, fn: () => T): T {
+    return spanRoot(name, fn, this.tracer)
+  }
+
+  async spanAsync<T>(name: string, fn: () => Promise<T>, config: SpanConfig = {}): Promise<T> {
+    return await spanRootAsync(name, fn, {
+      ...config, tracer: config.tracer ?? this.tracer, logger: config.logger ?? this.defaultLogger,
+    })
+  }
+
+  async start(): Promise<boolean> {
+    this._noOverride('start')
+    if (this.status === 'started') {
+      return true
+    }
+    return await this._statusMutex.runExclusive(async () => {
+      try {
+        // check again in case it changed
+        if (this.status === 'started') {
+          return true
+        }
+        assertEx(this.startable, () => `Creatable [${this.name}] is not startable in status [${this.status}]`)
+        this.setStatus('starting')
+        await this.startHandler()
+        this.setStatus('started')
+        return true
+      } catch (ex) {
+        this.setStatus('error', isError(ex) ? ex : new Error(`Error starting: ${ex}`))
+        this.logger?.error(`Error starting creatable [${this.name}]: ${(isError(ex) ? `${ex.message} ${ex.stack}` : ex)}`)
+        return false
+      }
+    })
+  }
+
+  started(notStartedAction: 'error' | 'throw' | 'warn' | 'log' | 'none' = 'log'): boolean {
+    if (isString(this.status) && this.status === 'started') {
+      return true
+    } else {
+      const message = () => `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`
+      switch (notStartedAction) {
+        case 'error': {
+          throw new Error(message())
+        }
+        case 'throw': {
+          throw new Error(message())
+        }
+        case 'warn': {
+          this.logger?.warn(message())
+          break
+        }
+        case 'log': {
+          this.logger?.log(message())
+          break
+        }
+        case 'none': {
+          break
+        }
+        default: {
+          throw new Error(`Unknown notStartedAction: ${notStartedAction}`)
+        }
+      }
+      return false
+    }
+  }
+
+  async startedAsync(notStartedAction: 'error' | 'throw' | 'warn' | 'log' | 'none' = 'log', tryStart = true): Promise<boolean> {
+    if (isString(this.status) && this.status === 'started') {
+      return true
+    } else if (this.status === 'created' || this.status === 'stopped' || this.status === 'starting') {
+      // using promise as mutex
+      this._startPromise = this._startPromise ?? (async () => {
+        if (tryStart) {
+          try {
+            return await this.start()
+          } finally {
+            this._startPromise = undefined
+          }
+        }
+        return this.started(notStartedAction)
+      })()
+    } else {
+      const message = `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`
+      throw new Error(message)
+    }
+
+    if (isUndefined(this._startPromise)) {
+      throw new Error(`Failed to create start promise: ${this.status}`)
+    }
+    return await this._startPromise
+  }
+
+  async stop(): Promise<boolean> {
+    this._noOverride('stop')
+    if (this.status === 'stopped') {
+      return true
+    }
+    return await this._statusMutex.runExclusive(async () => {
+      try {
+        // check again in case it changed
+        if (this.status === 'stopped') {
+          return true
+        }
+        assertEx(this.status === 'started', () => `Creatable [${this.name}] is not stoppable in status [${this.status}]`)
+        this.setStatus('stopping')
+        await this.stopHandler()
+        this.setStatus('stopped')
+        return true
+      } catch (ex) {
+        this.setStatus('error', isError(ex) ? ex : new Error(`Error stopping: ${ex}`))
+        return false
+      }
+    })
+  }
+
+  protected _noOverride(functionName = getFunctionName(3)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const thisFunc = (this as any)[functionName]
+
+    const rootFunc = getRootFunction(this, functionName)
+    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
+  }
+
+  protected setStatus(value: Exclude<CreatableStatusV2, 'error'>, progress?: number): void
+  protected setStatus(value: Extract<CreatableStatusV2, 'error'>, error?: Error): void
+  protected setStatus(value: CreatableStatusV2, progressOrError?: number | Error): void {
+    this._status = value
+    if (value !== null) {
+      if (value === 'error') {
+        if (isError(progressOrError)) {
+          this.statusReporter?.report(this.name, value, progressOrError)
+          return
+        }
+      } else {
+        if (isNumber(progressOrError)) {
+          this.statusReporter?.report(this.name, value, progressOrError)
+          return
+        }
+      }
+      this.statusReporter?.report(this.name, value)
+    }
+  }
+
+  protected startHandler(): Promisable<void> {
+    // when overriding this, throw an error on failure
+  }
+
+  protected stopHandler(): Promisable<void> {
+    // when overriding this, throw an error on failure
+  }
+}
+
+export abstract class AbstractCreatableWithFactoryV2<TParams extends CreatableParamsV2 = CreatableParamsV2,
+  TEventData extends EventData = EventData> extends AbstractCreatableV2<TParams, TEventData> {
+  static factory<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    params?: Partial<T['params']>,
+    labels?: Labels,
+  ): CreatableFactoryV2<T> {
+    return FactoryV2.withParams<T>(this, params, labels)
+  }
+}

package/src/Creatable.ts

@@ -7,6 +7,7 @@ import type {
   RequiredCreatableParams,
 } from './model/index.ts'
 
+/** @deprecated use CreatableFactoryV2 instead */
 export interface CreatableFactory<T extends CreatableInstance = CreatableInstance>
   extends Omit<Creatable<T>, 'create' | 'createHandler' | 'paramsHandler' | 'defaultLogger' | 'factory'> {
 
@@ -15,6 +16,7 @@ export interface CreatableFactory<T extends CreatableInstance = CreatableInstanc
     params?: Partial<T['params']>): Promise<T>
 }
 
+/** @deprecated use CreatableV2 instead */
 export interface Creatable<T extends CreatableInstance = CreatableInstance> {
 
   defaultLogger?: Logger
@@ -34,6 +36,7 @@ export interface Creatable<T extends CreatableInstance = CreatableInstance> {
     this: Creatable<T>, params?: Partial<T['params']>): Promisable<T['params'] & RequiredCreatableParams>
 }
 
+/** @deprecated use CreatableWithFactoryV2 instead */
 export interface CreatableWithFactory<T extends CreatableInstance = CreatableInstance> extends Creatable<T> {
   factory<T extends CreatableInstance>(
     this: Creatable<T>,
@@ -47,6 +50,7 @@ export interface CreatableWithFactory<T extends CreatableInstance = CreatableIns
  * @returns The decorated Module requiring it implement the members
  * of the CreatableModule as statics properties/methods
  */
+/** @deprecated use creatableV2 instead */
 export function creatable<T extends CreatableInstance>() {
   return <U extends Creatable<T>>(constructor: U) => {
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
@@ -61,6 +65,7 @@ export function creatable<T extends CreatableInstance>() {
  * of the CreatableModule as statics properties/methods
  */
 
+/** @deprecated use creatableFactoryV2 instead */
 export function creatableFactory() {
   return <U extends CreatableFactory>(constructor: U) => {
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions

package/src/CreatableV2.ts

@@ -0,0 +1,67 @@
+import type { Logger } from '@xylabs/logger'
+import type { Promisable } from '@xylabs/promise'
+
+import type {
+  CreatableInstanceV2, CreatableParamsV2, Labels,
+} from './model/index.ts'
+
+export interface CreatableFactoryV2<T extends CreatableInstanceV2 = CreatableInstanceV2>
+  extends Omit<CreatableV2<T>, 'create' | 'createHandler' | 'paramsHandler' | 'defaultLogger' | 'factory'> {
+
+  create(
+    this: CreatableFactoryV2<T>,
+    params?: Partial<T['params']>): Promise<T>
+}
+
+export interface CreatableV2<T extends CreatableInstanceV2 = CreatableInstanceV2> {
+
+  defaultLogger?: Logger
+
+  new(key: unknown, params: Partial<CreatableParamsV2>): T
+
+  create<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    params?: Partial<T['params']>): Promise<T>
+
+  createHandler<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    instance: T
+  ): Promisable<T>
+
+  paramsHandler<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>, params?: Partial<T['params']>): Promisable<T['params']>
+}
+
+export interface CreatableWithFactoryV2<T extends CreatableInstanceV2 = CreatableInstanceV2> extends CreatableV2<T> {
+  factory<T extends CreatableInstanceV2>(
+    this: CreatableV2<T>,
+    params?: Partial<T['params']>,
+    labels?: Labels): CreatableFactoryV2<T>
+}
+
+/**
+ * Class annotation to be used to decorate Modules which support
+ * an asynchronous creation pattern
+ * @returns The decorated Module requiring it implement the members
+ * of the CreatableModule as statics properties/methods
+ */
+export function creatableV2<T extends CreatableInstanceV2>() {
+  return <U extends CreatableV2<T>>(constructor: U) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    constructor
+  }
+}
+
+/**
+ * Class annotation to be used to decorate Modules which support
+ * an asynchronous creation factory pattern
+ * @returns The decorated Module requiring it implement the members
+ * of the CreatableModule as statics properties/methods
+ */
+
+export function creatableFactoryV2() {
+  return <U extends CreatableFactoryV2>(constructor: U) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    constructor
+  }
+}

package/src/FactoryV2.ts

@@ -0,0 +1,38 @@
+import type { CreatableFactoryV2, CreatableV2 } from './CreatableV2.ts'
+import type {
+  CreatableInstanceV2, Labels, WithOptionalLabels,
+} from './model/index.ts'
+
+export class FactoryV2<T extends CreatableInstanceV2 = CreatableInstanceV2> implements CreatableFactoryV2<T> {
+  creatable: CreatableV2<T>
+
+  defaultParams?: Partial<T['params']>
+
+  labels?: Labels
+
+  constructor(
+    creatable: CreatableV2<T>,
+    params?: Partial<T['params']>,
+    labels: Labels = {},
+  ) {
+    this.creatable = creatable
+    this.defaultParams = params
+    this.labels = Object.assign({}, (creatable as WithOptionalLabels).labels ?? {}, labels ?? {})
+  }
+
+  static withParams<T extends CreatableInstanceV2>(
+    creatableModule: CreatableV2<T>,
+    params?: Partial<T['params']>,
+    labels: Labels = {},
+  ) {
+    return new FactoryV2<T>(creatableModule, params, labels)
+  }
+
+  create(params?: Partial<T['params']>): Promise<T> {
+    const mergedParams: T['params'] = {
+      ...this.defaultParams,
+      ...params,
+    } as T['params']
+    return this.creatable.create<T>(mergedParams)
+  }
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './AbstractCreatable.ts'
 export * from './Creatable.ts'
 export * from './Factory.ts'
+export * from './FactoryV2.ts'
 export * from './model/index.ts'

package/src/model/CreatableInstance.ts

@@ -1,6 +1,7 @@
 import type { EventData, EventEmitter } from '@xylabs/events'
 
-import type { CreatableName, CreatableParams } from './CreatableParams.ts'
+import type { CreatableName } from './CreatableName.ts'
+import type { CreatableParams } from './CreatableParams.ts'
 
 export interface CreatableInstance<TParams extends CreatableParams = CreatableParams,
   TEventData extends EventData = EventData> extends EventEmitter<TEventData> {

package/src/model/CreatableInstanceV2.ts

@@ -0,0 +1,16 @@
+import type { EventData, EventEmitter } from '@xylabs/events'
+import type { Promisable } from '@xylabs/promise'
+
+import type { CreatableName } from './CreatableName.ts'
+import type { CreatableParamsV2 } from './CreatableParamsV2.ts'
+
+export interface CreatableInstanceV2<TParams extends CreatableParamsV2 = CreatableParamsV2,
+  TEventData extends EventData = EventData> extends EventEmitter<TEventData> {
+  createHandler: () => Promisable<void>
+  eventData: TEventData
+  name: CreatableName
+  params: TParams
+  setStatus: (status: string) => void
+  start: () => Promise<boolean>
+  stop: () => Promise<boolean>
+}

package/src/model/CreatableName.ts

@@ -0,0 +1,3 @@
+import type { BaseClassName } from '@xylabs/base'
+
+export type CreatableName = BaseClassName & { __creatableName: true }

package/src/model/CreatableParams.ts

@@ -1,10 +1,8 @@
-import type { BaseClassName } from '@xylabs/base'
 import type { BaseEmitterParams } from '@xylabs/events'
 
+import type { CreatableName } from './CreatableName.ts'
 import type { CreatableStatus, CreatableStatusReporter } from './CreatableStatusReporter.ts'
 
-export type CreatableName = Exclude<string, 'creatable-name-reserved-32546239486'> & BaseClassName
-
 export interface RequiredCreatableParams<TAdditionalStatus extends CreatableStatus | void = void> extends BaseEmitterParams {
   name?: CreatableName
   statusReporter?: CreatableStatusReporter<TAdditionalStatus>

package/src/model/CreatableParamsV2.ts

@@ -0,0 +1,11 @@
+import { BaseContextZod } from '@xylabs/base'
+import { BaseEmitterParamsV2Zod } from '@xylabs/events'
+import z from 'zod'
+
+import { CreatableStatusReporterV2Zod } from './CreatableStatusReporter.zod.ts'
+
+export const CreatableContext = z.intersection(BaseContextZod, z.object({ name: z.string(), statusReporter: CreatableStatusReporterV2Zod.optional() }))
+
+export const CreatableParamsV2Zod = BaseEmitterParamsV2Zod.extend(z.object({ context: CreatableContext, name: z.string() }).shape)
+
+export type CreatableParamsV2 = z.infer<typeof CreatableParamsV2Zod>

package/src/model/CreatableStatusReporter.ts

@@ -1,11 +1,15 @@
-import type { BaseClassName } from '@xylabs/base'
+import type { CreatableName } from './CreatableName.ts'
 
+/** @deprecated use CreatableStatusReporterV2 instead */
 export type StandardCreatableStatus = 'creating' | 'created' | 'starting' | 'started' | 'stopping' | 'stopped' | 'error'
+
+/** @deprecated use CreatableStatusReporterV2 instead */
 export type CreatableStatus<TAdditionalStatus extends void | string = void>
   = StandardCreatableStatus | (TAdditionalStatus extends void ? StandardCreatableStatus : TAdditionalStatus)
 
+/** @deprecated use CreatableStatusReporterV2 instead */
 export interface CreatableStatusReporter<TAdditionalStatus extends void | string = void> {
-  report(name: BaseClassName, status: Exclude<CreatableStatus<TAdditionalStatus>, 'error'>, progress: number): void
-  report(name: BaseClassName, status: Extract<CreatableStatus<TAdditionalStatus>, 'error'>, error: Error): void
-  report(name: BaseClassName, status: CreatableStatus<TAdditionalStatus>): void
+  report(name: CreatableName, status: Exclude<CreatableStatus<TAdditionalStatus>, 'error'>, progress: number): void
+  report(name: CreatableName, status: Extract<CreatableStatus<TAdditionalStatus>, 'error'>, error: Error): void
+  report(name: CreatableName, status: CreatableStatus<TAdditionalStatus>): void
 }