@validation-engineering/cordis-compat-deepseek 0.0.0-stage → 0.1.0

package/LICENSE

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

package/NOTICE

@@ -0,0 +1,49 @@
+This is an independent Rust reimplementation of a subset of Cordis semantics.
+It is not an official Cordis, DeepSeek, or Verus distribution.
+
+Design and behavior references:
+- Cordis, https://github.com/cordiverse/cordis (MIT)
+- DeepSeek Harness, https://github.com/deepseek-ai/deepseek-harness (MIT)
+- A Programming Paradigm for Spatiotemporal Composability,
+  https://arxiv.org/abs/2608.25512v1 (https://github.com/validation-engineering/cordis-verus/blob/main/reference/README.md)
+
+The ignored upstream checkouts retain their own license and copyright files.
+The reference paper is not covered by this project's MIT license.
+Verus binaries and vstd retain their upstream licenses. Binary archives are
+downloaded into the ignored .tools directory. Project-managed toolchain archives
+preserve original upstream bytes with a source/notices companion; see
+https://github.com/validation-engineering/cordis-verus/blob/main/docs/toolchains/README.md.
+They are separate from Cordis runtime releases.
+
+The experimental JavaScript compatibility package adapts language-layer code
+from Cordis (Copyright (c) 2021-present Shigma, MIT). The original MIT notice
+is preserved in packages/compat-cordis/LICENSE.upstream. It does not embed the
+upstream Fiber lifecycle scheduler. Node-API dependencies retain their own licenses.
+
+The compatibility logger in packages/compat-cordis/logger.js is adapted from
+Cordis packages/core/src/logger.ts at the locked Cordis revision. Its formatting,
+exporter and traceable-caller behavior are ordinary JavaScript, outside the
+Verus proof boundary, and retain the same MIT attribution above.
+
+Windows configuration persistence uses atomicwrites 0.4.4
+(https://github.com/untitaker/rust-atomicwrites), under the MIT license:
+
+Copyright (c) 2015 Markus Unterwaditzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,24 @@
-# Temporary Holding Version
+# DeepSeek Cordis compatibility
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@validation-engineering/cordis-compat-deepseek` provides compatibility with the pinned **`@deepseek-ai/cordis` 4.0.4** interface over the shared Rust driver. It is a Cordis runtime interface, not the complete DeepSeek Harness application. Use the companion Harness application for the official CLI, Web UI and agent workflows.
+
+The name identifies the compatible runtime distribution: **Cordis**, **compatibility**, **DeepSeek**. This replaces the ambiguous `@validation-engineering/cordis-harness` package name. The internal `harness` policy and lifecycle behavior remain unchanged. See [package boundaries and migration](../../docs/package-boundaries.md).
+
+```js
+import { Context } from '@validation-engineering/cordis-compat-deepseek';
+const app = new Context();
+const instance = await app.plugin((ctx, config) => {
+  ctx.logger.info('started', config);
+}, { enabled: true });
+instance.update({ enabled: false }); // Harness update returns void
+await instance.await();
+await app.dispose();
+```
+
+For unchanged plugins importing the upstream name, start Node 22.22 or newer with `--import @validation-engineering/cordis-compat-deepseek/register`. ESM, dynamic import, CommonJS and createRequire route bare `@deepseek-ai/cordis` to this package. Mixed Cordis profiles and upstream deep imports are rejected by the bootstrap. The core npm package includes the matching precompiled native addon for all four supported platforms; compiling is only needed for source development or custom native code.
+
+Raw configuration is resolved through `internal/config` and Standard Schema on every activation, after required services are available. Pending updates defer resolution. Active updates resolve synchronously and emit `internal/update`; their return value is void. Related dependency notifications may retry failed setup. Cleanup failures remain blocked until an explicit retry succeeds.
+
+The facade intentionally fixes the upstream wrapper receiver defect: `ctx.plugin(...).update(...)` targets the actual fiber, just as the standalone profile does. Native cancellation, publication lease draining and cleanup failure reporting are stronger contracts than upstream; full behavioral equality is not claimed. The shared Logger/Context/Service API does not mean every Harness Loader, lazy/volatile configuration, HMR or application package is supported. See `docs/node-compatibility.md` for the evidence matrix.
+
+Type declarations are generated from the common facade surface by `scripts/sync-profile-types.mjs`, with Harness's void update contract and its own Context augmentation scope.

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./index.js');

package/index.d.ts

@@ -0,0 +1,270 @@
+// Generated by scripts/sync-profile-types.mjs; edit the common Cordis declarations.
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+/** Pull-driven Rust resource. At most one next() may be outstanding. */
+export interface RustStream<T extends JsonValue = JsonValue> extends AsyncIterableIterator<T> {
+  next(): Promise<IteratorResult<T, undefined>>;
+  return(): Promise<IteratorResult<T, undefined>>;
+  throw(error: unknown): Promise<IteratorResult<T, undefined>>;
+}
+declare const objectAdapterBrand: unique symbol;
+/** Explicit factory return value; cannot be encoded in ordinary JSON arguments. */
+export interface JavaScriptObjectAdapter { readonly [objectAdapterBrand]: true; }
+export type ObjectAdapterOptions<T extends object> = {
+  readonly typeName: string;
+  readonly methods: readonly string[];
+} & ({readonly ownership: 'borrowed'; readonly dispose?: never} | {
+  readonly ownership: 'owned'; readonly dispose: (target: T) => Awaitable<void>;
+});
+export function adaptObject<T extends object>(target: T, options: ObjectAdapterOptions<T>): JavaScriptObjectAdapter;
+export function adaptCallback<T extends (...args: any[]) => Awaitable<JsonValue | void>>(callback: T, options?: {
+  readonly typeName?: string;
+} & ({readonly ownership?: 'borrowed'; readonly dispose?: never} | {
+  readonly ownership: 'owned'; readonly dispose: (callback: T) => Awaitable<void>;
+})): JavaScriptObjectAdapter;
+export interface RustObject {
+  readonly typeName: string;
+  readonly ownership: 'borrowed' | 'owned';
+  readonly methods: readonly string[];
+  call(method: string, ...args: JsonValue[]): Promise<JsonValue>;
+  close(): Promise<void>;
+}
+export interface RustCallback extends RustObject {
+  invoke(...args: JsonValue[]): Promise<JsonValue>;
+}
+export type Awaitable<T> = T | PromiseLike<T>;
+export type Disposable = () => Awaitable<void>;
+export type Effect = void | Disposable | PromiseLike<void | Disposable> | Iterable<void | Disposable> | AsyncIterable<void | Disposable>;
+export interface AsyncDisposable extends Disposable { then<TResult1 = Disposable, TResult2 = never>(onfulfilled?: ((value: Disposable) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>; }
+export interface OwnedTask<T> { readonly promise: Promise<T>; readonly signal: AbortSignal; cancel(reason?: unknown): void; join(): Promise<T>; }
+export type Inject = string[] | Record<string, unknown>;
+export interface PluginOptions<T = any> { name?: string; inject?: Inject; provide?: string | string[]; Config?: { '~standard': { validate(value: unknown): { value: T } | { issues: readonly {message: string}[] } } }; }
+export type Plugin<T = any> = Plugin.Function<T> | Plugin.Constructor<T> | Plugin.Object<T>;
+export namespace Plugin {
+  interface Function<T = any> extends PluginOptions<T> { (ctx: Context, config: T): Effect; }
+  interface Constructor<T = any> extends PluginOptions<T> { new (ctx: Context, config: T): object; }
+  interface Object<T = any> extends PluginOptions<T> { apply(ctx: Context, config: T): Effect; }
+}
+export interface Events { [name: string | symbol]: (...args: any[]) => any; }
+export interface EventOptions { prepend?: boolean; global?: boolean; }
+/** Record counts, not allocated bytes. Node/publication tombstones remain; released lease records are removed. */
+export interface DriverStorageStats {
+  registeredPlugins: number;
+  identitySlots: number;
+  declarationRecords: number;
+  bindingRecords: number;
+  liveBindings: number;
+  publicationRecords: number;
+  /** Actual stored lease records, including leases held by failed cleanup. */
+  leaseRecords: number;
+  /** Cumulative successful allocations; lease IDs never repeat. */
+  leaseAllocations: number;
+  liveLeases: number;
+  publishedValues: number;
+  pendingActions: number;
+}
+/** Decimal strings preserve native identities beyond JavaScript's safe integers. */
+export interface DiagnosticPort { key: string; realm: string; service?: string; realmLabel?: string; }
+export interface EpisodeIdentity { id: string; generation: string | null; }
+export interface DiagnosticBinding extends DiagnosticPort {
+  provider: string;
+  generation: string | null;
+  publication: string | null;
+}
+export type DiagnosticPhase = 'Pending' | 'Failed' | 'Loading' | 'Active' | 'Unloading';
+export interface DriverActionTicket { domain: string; id: string; generation: string; action: string; kind: 'setup' | 'cleanup'; }
+export interface DriverCheckTicket {
+  domain: string; consumer: string; port: DiagnosticPort; publication: string;
+  value_revision: string; notification: string; action: string;
+}
+export interface DiagnosticCheck { port: DiagnosticPort; provider: string; publication: string; }
+export type DriverBlocker =
+  | {code: 'MissingProvider'; port: DiagnosticPort}
+  | {code: 'RealmMismatch'; port: DiagnosticPort; observedRealms: string[]}
+  | {code: 'ProviderUnavailable'; port: DiagnosticPort; providers: (EpisodeIdentity & {state: DiagnosticPhase; retired: boolean})[]}
+  | {code: 'PublicationMissing'; port: DiagnosticPort; provider: string}
+  | (DiagnosticCheck & {code: 'CheckNotEvaluated' | 'CheckRejected'})
+  | (DiagnosticCheck & {code: 'CheckPending'; ticket: DriverCheckTicket})
+  | (DiagnosticCheck & {code: 'CheckError'; error: string})
+  | (DiagnosticCheck & ({code: 'CheckInvalidated'; ticket: DriverCheckTicket} | {code: 'CheckInvalidated'; error: string | null}))
+  | {code: 'CommittedConsumers'; consumers: EpisodeIdentity[]}
+  | {code: 'PendingAction'; ticket: DriverActionTicket}
+  | {code: 'RetiringChildren'; children: EpisodeIdentity[]}
+  | {code: 'CleanupFailed'; error: string | null; retryable: true}
+  | {code: 'Failed'; error: string}
+  | {code: 'TargetChanged' | 'Unsealed'};
+export interface InverseObservation {
+  id: string; owner: string; generation: string | null; registeredGeneration: string | null; parent: string | null;
+  label: string; state: 'registered' | 'waiting' | 'running' | 'failed'; attempts: number;
+  error?: string;
+  /** Observed duration of this running attempt; only with includeTiming. */
+  elapsedMs?: number;
+}
+export interface HostObservation {
+  inverses: InverseObservation[];
+  action?: {ticket: DriverActionTicket; stage: 'setup' | 'cleanup' | 'draining-tasks' | 'inverses' | 'draining-calls' | 'closing-objects' | 'closing-sessions'; elapsedMs?: number};
+}
+export interface DriverPluginSnapshot extends EpisodeIdentity {
+  parent: string | null; state: DiagnosticPhase; retired: boolean; error: string | null;
+  cleanupFailed: boolean; pendingAction: DriverActionTicket | null;
+  dependencies: DiagnosticPort[]; committed: DiagnosticBinding[]; target: DiagnosticBinding[] | null;
+  blockers: DriverBlocker[]; host?: HostObservation;
+}
+export interface DriverSnapshot {
+  abi: 1; diagnosticsSchema: 'cordis.driver/v1'; domain: string; profile: 'cordis' | 'harness';
+  plugins: DriverPluginSnapshot[]; storage: DriverStorageStats;
+  checkErrors: (DiagnosticPort & {consumer: string; error: string})[];
+  diagnostics: {kind: 'service-check' | 'mutation-step'; consumer?: string; error: string}[];
+}
+export interface EpisodeErrorDetails {
+  owner: string | null; requestedGeneration: string | null; currentGeneration: string | null;
+  removed: boolean; operation: string;
+}
+export class Context {
+  static readonly effect: unique symbol;
+  static readonly filter: unique symbol;
+  static readonly isolate: unique symbol;
+  static readonly intercept: unique symbol;
+  static is(value: unknown): value is Context;
+  constructor(options?: { addon?: string });
+  root: this;
+  fiber: Fiber;
+  registry: RegistryService;
+  reflect: ReflectService;
+  events: EventsService;
+  logger: LoggerService;
+  [Context.isolate]: Record<string, symbol>;
+  [Context.intercept]: Record<string, any>;
+  extend(meta?: object): this;
+  isolate(name: string, label?: symbol): this;
+  intercept(name: string, config: unknown): this;
+  plugin<T>(plugin: Plugin<T>, config?: T): Fiber & PromiseLike<Fiber>;
+  rustPlugin(name: string, config?: JsonValue): Fiber & PromiseLike<Fiber>;
+  inject(deps: Inject, callback: (ctx: Context) => Effect): Fiber & PromiseLike<Fiber>;
+  effect(execute: () => Effect, label?: string): AsyncDisposable;
+  task<T>(execute: (signal: AbortSignal) => Awaitable<T>, label?: string): OwnedTask<Awaited<T>>;
+  get(name: string, strict?: boolean): any;
+  set(name: string, value: any): void;
+  provide(name: string, value?: any, check?: () => boolean): AsyncDisposable;
+  accessor(name: string, options: { get(this: Context, receiver: any, error: Error): any; set?(this: Context, value: any, receiver: any, error: Error): boolean }): AsyncDisposable;
+  mixin(source: string | object, mixins: string[] | Record<string,string>): AsyncDisposable;
+  on<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): Disposable;
+  once<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): Disposable;
+  emit<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): void;
+  bail(name: keyof Events, ...args: any[]): any;
+  serial(name: keyof Events, ...args: any[]): Promise<any>;
+  parallel(name: keyof Events, ...args: any[]): Promise<void>;
+  waterfall(name: keyof Events, ...args: any[]): any;
+  settle(): Promise<void>;
+  dispose(): Promise<void>;
+  /** Read-only observation. Timing is opt-in and does not diagnose deadlock or progress. */
+  snapshot(options?: {includeTiming?: boolean}): DriverSnapshot;
+}
+export const FiberState: Readonly<{PENDING: 0; LOADING: 1; ACTIVE: 2; FAILED: 3; DISPOSED: 4; UNLOADING: 5}>;
+export class Fiber {
+  readonly id: string;
+  uid: number | null;
+  readonly ctx: Context;
+  readonly parent: Context;
+  state: number;
+  /** Current native-admitted setup/cleanup transition; failure is reported by await(). */
+  inertia: Promise<void> | undefined;
+  config: any;
+  inject: Record<string, any>;
+  runtime: {name?: string; callback: Function; fibers: Iterable<Fiber>} | null;
+  readonly name: string;
+  dispose(): Promise<void>;
+  await(): Promise<Fiber>;
+  effect(execute: () => Effect, label?: string): AsyncDisposable;
+  task<T>(execute: (signal: AbortSignal) => Awaitable<T>, label?: string): OwnedTask<Awaited<T>>;
+  restart(): Promise<void>;
+  retryCleanup(): Promise<void>;
+  update(config: any, noSave?: boolean): void;
+  getEffects(): {label: string;children: unknown[]}[];
+}
+export abstract class Service<T = never> {
+  static readonly init: unique symbol;
+  static readonly check: unique symbol;
+  static readonly config: unique symbol;
+  static readonly invoke: unique symbol;
+  static readonly extend: unique symbol;
+  static readonly tracker: unique symbol;
+  static readonly resolveConfig: unique symbol;
+  protected ctx: Context;
+  name: string;
+  constructor(ctx: Context, name?: string);
+  [Service.config]: T;
+  protected [Service.extend](props?: object): this;
+  [Service.resolveConfig](base?: T, head?: T): T;
+}
+export class RegistryService {
+  readonly size: number;
+  plugin<T>(plugin: Plugin<T>, config?: T): Fiber & PromiseLike<Fiber>;
+  inject(deps: Inject, callback: (ctx: Context) => Effect): Fiber & PromiseLike<Fiber>;
+  get(plugin: Plugin): object | undefined;
+  has(plugin: Plugin): boolean;
+  delete(plugin: Plugin): object | undefined;
+  keys(): IterableIterator<Function>;
+  values(): IterableIterator<any>;
+}
+export class ReflectService { get(name: string, strict?: boolean): any; set(name: string, value: any): boolean; provide(name: string, value?: any, check?: () => boolean): AsyncDisposable; notify(names: string[]): Fiber[]; trace<T>(value: T): T; bind<T extends Function>(callback: T): T; }
+export class EventsService { }
+export class CordisError extends Error {
+  constructor(code: string, message?: string, details?: EpisodeErrorDetails);
+  readonly code: string;
+  readonly details?: Readonly<EpisodeErrorDetails>;
+}
+export class ValidationError extends TypeError { }
+export function Inject(name: string, config?: unknown): (value: any, decorator: ClassDecoratorContext | ClassMethodDecoratorContext) => void;
+export namespace Inject { function resolve(inject?: Inject): Record<string,unknown>; }
+export const symbols: Record<string,symbol>;
+
+export type LoggerType = 'error' | 'info' | 'warn' | 'debug';
+export const LoggerLevel: Readonly<{ERROR: 0; WARN: 1; INFO: 2; DEBUG: 3}>;
+export interface Message { sn: number; ts: number; name: string; type: LoggerType; level: number; args: any[]; fiber?: WeakRef<Fiber>; }
+export type Formatter = (value: any, exporter: Exporter, message: Message) => any;
+export interface Exporter { colors?: number | false; maxLength?: number; levels?: Record<string, number>; formatters?: Record<string, Formatter>; export(message: Message): void; }
+export interface LoggerOptions { name: string; meta?: Partial<Message>; level?: number; }
+export class Logger {
+  constructor(options: LoggerOptions, service: LoggerService);
+  static color(exporter: Exporter, code: number, value: any, decoration?: string): string;
+  static code(name: string, level?: false | number): number;
+  static format(exporter: Exporter, message: Message): string;
+  name: string;
+  error(...args: any[]): void;
+  warn(...args: any[]): void;
+  info(...args: any[]): void;
+  debug(...args: any[]): void;
+}
+export interface LoggerService { (name?: string): Logger; }
+export class LoggerService {
+  constructor(ctx: Context);
+  bufferSize: number;
+  buffer: Message[];
+  exporters: Map<number, Exporter>;
+  exporter(exporter: Exporter): AsyncDisposable;
+  error(...args: any[]): void;
+  warn(...args: any[]): void;
+  info(...args: any[]): void;
+  debug(...args: any[]): void;
+}
+export const defaultFormatters: Record<string, Formatter>;
+export const c16: number[];
+export const c256: number[];
+
+/** Explicit external revision transaction; lifecycle callbacks cannot nest it. */
+export interface MutationSteps {
+  /** True only in this live coordinator callback, never in managed observers. */
+  isCurrent(): boolean;
+  /** Run a callback with its owner's episode identity and without transaction authority. */
+  observe<T>(fiber: Fiber, execute: () => T): T extends PromiseLike<unknown> ? Promise<Awaited<T>> : T;
+  /** Join synchronous adapter lifecycle calls; authority ends before async continuation. */
+  capture<T>(execute: () => T): T;
+  dispose(fiber: Fiber): Promise<void>;
+  restart(fiber: Fiber): Promise<void>;
+  retryCleanup(fiber: Fiber): Promise<void>;
+  update(fiber: Fiber, config: any, noSave?: boolean): Awaitable<void>;
+}
+export function domainMutation<T>(ctx: Context, execute: (steps: Readonly<MutationSteps>) => Awaitable<T>, options?: { recovery?: boolean }): Promise<T>;
+
+/** Check admission without queuing or changing domain state. */
+export function assertDomainMutation(ctx: Context, options?: { recovery?: boolean }): void;

package/index.js

@@ -0,0 +1,5 @@
+export * from '@validation-engineering/cordis';
+import { Context as CoreContext } from '@validation-engineering/cordis';
+export class Context extends CoreContext {
+  constructor(options = {}) { super({...options, profile:'harness'}); }
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@validation-engineering/cordis-compat-deepseek",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Compatibility with @deepseek-ai/cordis over the Rust/Verus Cordis runtime; not the DeepSeek Harness application",
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./register": "./register.js"
+  },
+  "peerDependencies": {
+    "@validation-engineering/cordis": "0.1.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/validation-engineering/cordis-verus.git",
+    "directory": "packages/compat-deepseek"
+  },
+  "homepage": "https://github.com/validation-engineering/cordis-verus#readme",
+  "bugs": {
+    "url": "https://github.com/validation-engineering/cordis-verus/issues"
+  },
+  "files": [
+    "*.js",
+    "*.cjs",
+    "*.d.ts",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ]
+}

package/register.js

@@ -0,0 +1,2 @@
+import { registerProfile } from '@validation-engineering/cordis/bootstrap';
+export const registration = registerProfile('harness', new URL('./index.js', import.meta.url).href, new URL('./index.cjs', import.meta.url).href);