@sincpro/client-framework 0.0.0-stage → 0.1.0

package/dist/services/execution.d.ts

@@ -0,0 +1,63 @@
+import type { Transport } from "../client/transport.js";
+import type { Span } from "../observability/ports.js";
+/**
+ * One run of a use case: its span, what it runs with, and who ran it.
+ *
+ * Context: sincpro_framework keeps the running use case in a context variable; a browser has
+ * nothing like it that survives an `await` (AsyncContext is a proposal, Zone.js patches the
+ * world), and a global stack mixes the parents of two use cases running at once — which a
+ * screen with several windows does all the time. So an execution is a value, handed to what
+ * the use case calls: its Features (`ApplicationService`) and its dependencies (`BIND`).
+ */
+export type Execution = {
+    /** UUID v7, as 32 hex: this run. */
+    readonly id: string;
+    /** `<domain>/<Feature>` — the span's name, as the backend names its own. */
+    readonly useCase: string;
+    /** The bounded context the use case belongs to, when it was bound to one. */
+    readonly domain: string | undefined;
+    /** The run that executed this one: an ApplicationService, for its Features. */
+    readonly parent: Execution | undefined;
+    readonly span: Span;
+    /** What it runs with, read once where the gesture started and inherited by every child. */
+    readonly context: Readonly<Record<string, unknown>>;
+};
+/**
+ * A dependency that has something to say about the execution it is used in: given that
+ * execution, it answers itself bound to it. The transport and every generated client are;
+ * anything else in a Feature's `deps` is handed as it is.
+ */
+export declare const BIND: unique symbol;
+export type Bindable<T> = {
+    [BIND]: (execution: Execution) => T;
+};
+/**
+ * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
+ * (`sincpro-context`, the header sincpro_framework's entrances read). Nothing when there is no
+ * trace and no context.
+ */
+export declare function headersOf(execution: Execution): Record<string, string>;
+/**
+ * The transport, writing the execution's headers on every call — the caller's own headers of a
+ * call still win.
+ *
+ * Context: the transport's own headers (`restTransport({ headers })`) are the session's — the
+ * token, the tenant — the same for every call; these are the use case's, different for two use
+ * cases running at once, so they travel per call (`CallOptions`).
+ */
+export declare function bindTransport(transport: Transport, execution: Execution): Transport;
+/**
+ * A client made over a transport, made again over the transport bound to each execution it is
+ * used in. What a generated `clientOf(transport)` answers, so a Feature that calls
+ * `this.deps.project.sendIssue(…)` sends that request with its own trace.
+ *
+ *     export function clientOf(transport: Transport) {
+ *       return bindable(transport, (transport) => ({ sendIssue: (body) => transport.send(…) }));
+ *     }
+ *
+ * Context: it takes the function that makes the client, not the client — rebuilding through
+ * `clientOf` itself would make TypeScript infer `clientOf` from its own return.
+ */
+export declare function bindable<T extends object>(transport: Transport, make: (transport: Transport) => T): T;
+/** A dependency as the execution should see it: bound when it can be, as it is otherwise. */
+export declare function bindDependency<T>(value: T, execution: Execution): T;

package/dist/services/execution.js

@@ -0,0 +1,88 @@
+/**
+ * A dependency that has something to say about the execution it is used in: given that
+ * execution, it answers itself bound to it. The transport and every generated client are;
+ * anything else in a Feature's `deps` is handed as it is.
+ */
+export const BIND = Symbol.for("sincpro.client-framework.bind");
+function isBindable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[BIND] === "function");
+}
+function isTransport(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const one = value;
+    return (typeof one.list === "function" &&
+        typeof one.one === "function" &&
+        typeof one.send === "function");
+}
+/**
+ * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
+ * (`sincpro-context`, the header sincpro_framework's entrances read). Nothing when there is no
+ * trace and no context.
+ */
+export function headersOf(execution) {
+    const headers = {};
+    const { span, context } = execution;
+    if (span.traceId !== "" && span.spanId !== "") {
+        headers["traceparent"] =
+            `00-${span.traceId}-${span.spanId}-${span.sampled ? "01" : "00"}`;
+        if (span.state)
+            headers["tracestate"] = span.state;
+    }
+    if (Object.keys(context).length > 0)
+        headers["sincpro-context"] = JSON.stringify(context);
+    return headers;
+}
+/**
+ * The transport, writing the execution's headers on every call — the caller's own headers of a
+ * call still win.
+ *
+ * Context: the transport's own headers (`restTransport({ headers })`) are the session's — the
+ * token, the tenant — the same for every call; these are the use case's, different for two use
+ * cases running at once, so they travel per call (`CallOptions`).
+ */
+export function bindTransport(transport, execution) {
+    const own = headersOf(execution);
+    if (Object.keys(own).length === 0)
+        return transport;
+    const call = (options) => ({ ...options, headers: { ...own, ...options?.headers } });
+    const bound = {
+        list: (route, criteria, signal, options) => transport.list(route, criteria, signal, call(options)),
+        one: (route, signal, options) => transport.one(route, signal, call(options)),
+        send: (method, route, body, signal, options) => transport.send(method, route, body, signal, call(options)),
+    };
+    const read = transport.read;
+    if (read !== undefined)
+        bound.read = (route, signal, options) => read.call(transport, route, signal, call(options));
+    return bound;
+}
+/**
+ * A client made over a transport, made again over the transport bound to each execution it is
+ * used in. What a generated `clientOf(transport)` answers, so a Feature that calls
+ * `this.deps.project.sendIssue(…)` sends that request with its own trace.
+ *
+ *     export function clientOf(transport: Transport) {
+ *       return bindable(transport, (transport) => ({ sendIssue: (body) => transport.send(…) }));
+ *     }
+ *
+ * Context: it takes the function that makes the client, not the client — rebuilding through
+ * `clientOf` itself would make TypeScript infer `clientOf` from its own return.
+ */
+export function bindable(transport, make) {
+    const client = make(transport);
+    Object.defineProperty(client, BIND, {
+        value: (execution) => bindable(bindTransport(transport, execution), make),
+        enumerable: false,
+    });
+    return client;
+}
+/** A dependency as the execution should see it: bound when it can be, as it is otherwise. */
+export function bindDependency(value, execution) {
+    if (isBindable(value))
+        return value[BIND](execution);
+    if (isTransport(value))
+        return bindTransport(value, execution);
+    return value;
+}

package/dist/services/feature.d.ts

@@ -0,0 +1,60 @@
+import { type Runtime } from "./runtime.js";
+/**
+ * One use case. What it needs from outside — the generated client of its domain, another
+ * adapter — comes in `deps`, typed by the subclass.
+ *
+ *     export class SendIssue extends Feature<{ project: ProjectClient }> {
+ *       execute(input: dto.CommandSendIssue) {
+ *         return this.deps.project.sendIssue(input);
+ *       }
+ *     }
+ *
+ * Context: all of a client's logic lives in Features and ApplicationServices, as in
+ * sincpro_framework and @sincpro/mobile, and none of them writes a span or catches an error to
+ * report it: `new` answers the instance behind interceptors, and every public method runs
+ * inside its own execution — a span named `<domain>/<name>`, the context it runs with, its
+ * report if nobody expected how it failed. `execute` is a use case's entry; another public
+ * method is traced as `<name>.<method>`, and a name that starts with `_` is not traced at all.
+ *
+ * Inside a method, `this.deps` and `this.context` are this run's own: each dependency that can
+ * be (the transport, a generated client) is bound to the execution, so its requests carry this
+ * run's trace. So a Feature keeps nothing of a request on `this`, and declares no `#private`
+ * fields — the run sees the instance through a view of its own, and `#private` refuses views;
+ * TypeScript's `private` is the same promise without that.
+ */
+export declare class Feature<Deps extends object = Record<string, never>> {
+    protected readonly deps: Deps;
+    /** What this run executes with (`RuntimeOptions.context`): empty outside a run. */
+    protected readonly context: Readonly<Record<string, unknown>>;
+    constructor(deps?: Deps);
+}
+/**
+ * A use case that composes the Features of its own domain — the only difference with a
+ * Feature. Each call to one of them is a child of this run: its span under this span, the same
+ * context, the same trace on the wire.
+ *
+ *     export class CloseIssue extends ApplicationService<{ preview: PreviewClose; send: SendIssue }> {
+ *       async execute(input: CloseIssueInput) {
+ *         const preview = await this.features.preview.execute(input);
+ *         if (preview.warnings.length > 0) return { blocked: preview };
+ *         return this.features.send.execute({ ...input, message: "cerrado" });
+ *       }
+ *     }
+ *
+ * Context: it never executes another ApplicationService — sincpro_framework's rule, refused here
+ * when it is constructed rather than found in a trace later.
+ */
+export declare class ApplicationService<Features extends Readonly<Record<string, Feature<object>>>, Deps extends object = Record<string, never>> extends Feature<Deps> {
+    protected readonly features: Features;
+    constructor(features: Features, deps?: Deps);
+}
+/**
+ * The services of a bounded context, each running in this runtime under that domain: traced as
+ * `<domain>/<key>`, reported by its reporter, with its context.
+ *
+ *     const project = bindServices(runtime, "project", { sendIssue, closeIssue });
+ *
+ * Context: a span is named by the key it is bound with, not by the class — a production build
+ * renames classes, never the keys of an object.
+ */
+export declare function bindServices<Services extends Readonly<Record<string, Feature<object>>>>(runtime: Runtime, domain: string, services: Services): Services;

package/dist/services/feature.js

@@ -0,0 +1,206 @@
+import { newEntityId } from "../client/ids.js";
+import { bindDependency } from "./execution.js";
+import { DETACHED } from "./runtime.js";
+/**
+ * One use case. What it needs from outside — the generated client of its domain, another
+ * adapter — comes in `deps`, typed by the subclass.
+ *
+ *     export class SendIssue extends Feature<{ project: ProjectClient }> {
+ *       execute(input: dto.CommandSendIssue) {
+ *         return this.deps.project.sendIssue(input);
+ *       }
+ *     }
+ *
+ * Context: all of a client's logic lives in Features and ApplicationServices, as in
+ * sincpro_framework and @sincpro/mobile, and none of them writes a span or catches an error to
+ * report it: `new` answers the instance behind interceptors, and every public method runs
+ * inside its own execution — a span named `<domain>/<name>`, the context it runs with, its
+ * report if nobody expected how it failed. `execute` is a use case's entry; another public
+ * method is traced as `<name>.<method>`, and a name that starts with `_` is not traced at all.
+ *
+ * Inside a method, `this.deps` and `this.context` are this run's own: each dependency that can
+ * be (the transport, a generated client) is bound to the execution, so its requests carry this
+ * run's trace. So a Feature keeps nothing of a request on `this`, and declares no `#private`
+ * fields — the run sees the instance through a view of its own, and `#private` refuses views;
+ * TypeScript's `private` is the same promise without that.
+ */
+export class Feature {
+    deps;
+    /** What this run executes with (`RuntimeOptions.context`): empty outside a run. */
+    context = NO_CONTEXT;
+    constructor(deps) {
+        this.deps = deps ?? {};
+        // A class constructor that answers another object hands THAT to `new` and to every subclass
+        // constructor after it: their fields land on the instance through the proxy.
+        return intercepted(this, { runtime: DETACHED, domain: undefined, name: undefined });
+    }
+}
+/**
+ * A use case that composes the Features of its own domain — the only difference with a
+ * Feature. Each call to one of them is a child of this run: its span under this span, the same
+ * context, the same trace on the wire.
+ *
+ *     export class CloseIssue extends ApplicationService<{ preview: PreviewClose; send: SendIssue }> {
+ *       async execute(input: CloseIssueInput) {
+ *         const preview = await this.features.preview.execute(input);
+ *         if (preview.warnings.length > 0) return { blocked: preview };
+ *         return this.features.send.execute({ ...input, message: "cerrado" });
+ *       }
+ *     }
+ *
+ * Context: it never executes another ApplicationService — sincpro_framework's rule, refused here
+ * when it is constructed rather than found in a trace later.
+ */
+export class ApplicationService extends Feature {
+    features;
+    constructor(features, deps) {
+        super(deps);
+        for (const [name, feature] of Object.entries(features))
+            if (targetOf(feature) instanceof ApplicationService)
+                throw new Error(`${this.constructor.name}: "${name}" is an ApplicationService — an ApplicationService executes Features, never another ApplicationService`);
+        this.features = features;
+    }
+}
+/**
+ * The services of a bounded context, each running in this runtime under that domain: traced as
+ * `<domain>/<key>`, reported by its reporter, with its context.
+ *
+ *     const project = bindServices(runtime, "project", { sendIssue, closeIssue });
+ *
+ * Context: a span is named by the key it is bound with, not by the class — a production build
+ * renames classes, never the keys of an object.
+ */
+export function bindServices(runtime, domain, services) {
+    return Object.fromEntries(Object.entries(services).map(([name, service]) => [
+        name,
+        intercepted(targetOf(service), { runtime, domain, name }),
+    ]));
+}
+const NO_CONTEXT = Object.freeze({});
+const TARGETS = new WeakMap();
+function targetOf(feature) {
+    return TARGETS.get(feature) ?? feature;
+}
+/** The methods a class adds over Feature — what is traced — read once per class. */
+const METHODS = new WeakMap();
+function methodsOf(target) {
+    const prototype = Object.getPrototypeOf(target);
+    const known = METHODS.get(prototype);
+    if (known !== undefined)
+        return known;
+    const names = new Set();
+    for (let level = prototype; level !== null && level !== Feature.prototype && level !== Object.prototype; level = Object.getPrototypeOf(level))
+        for (const name of Object.getOwnPropertyNames(level)) {
+            const descriptor = Object.getOwnPropertyDescriptor(level, name);
+            if (name !== "constructor" &&
+                !name.startsWith("_") &&
+                typeof descriptor?.value === "function")
+                names.add(name);
+        }
+    METHODS.set(prototype, names);
+    return names;
+}
+function intercepted(target, binding) {
+    const proxy = new Proxy(target, {
+        get(held, property) {
+            const value = Reflect.get(held, property, held);
+            if (typeof property !== "string" || typeof value !== "function")
+                return value;
+            if (!methodsOf(held).has(property))
+                return value;
+            return (...args) => run(held, property, value, args, binding);
+        },
+    });
+    TARGETS.set(proxy, target);
+    return proxy;
+}
+function quietly(work, otherwise) {
+    try {
+        return work();
+    }
+    catch {
+        return otherwise;
+    }
+}
+const NO_SPAN = {
+    traceId: "",
+    spanId: "",
+    sampled: false,
+    set: () => undefined,
+    end: () => undefined,
+};
+function run(target, method, body, args, binding) {
+    const { runtime, domain, parent } = binding;
+    const name = binding.name ?? target.constructor.name;
+    const useCase = `${domain === undefined ? "" : `${domain}/`}${name}${method === "execute" ? "" : `.${method}`}`;
+    const context = parent?.context ?? quietly(() => runtime.context(), NO_CONTEXT);
+    const composes = target instanceof ApplicationService;
+    const id = newEntityId();
+    const attributes = {
+        "sincpro.use_case": useCase,
+        "sincpro.layer": composes ? "application_service" : "feature",
+        "sincpro.execution_id": id,
+        ...(domain === undefined ? {} : { "sincpro.domain": domain }),
+    };
+    const span = quietly(() => runtime.tracer.start(useCase, {
+        ...(parent === undefined ? {} : { parent: parent.span }),
+        attributes,
+    }), NO_SPAN);
+    const execution = { id, useCase, domain, parent, span, context };
+    // The run's own view of the instance: its dependencies bound to this execution, its context,
+    // and — for an ApplicationService — its Features as children of this run.
+    const own = target;
+    const view = Object.create(target, {
+        deps: {
+            value: Object.fromEntries(Object.entries(own.deps ?? {}).map(([key, dependency]) => [
+                key,
+                bindDependency(dependency, execution),
+            ])),
+        },
+        context: { value: context },
+        ...(composes
+            ? {
+                features: {
+                    value: Object.fromEntries(Object.entries(own.features ?? {}).map(([key, feature]) => [
+                        key,
+                        intercepted(targetOf(feature), {
+                            runtime,
+                            domain,
+                            name: key,
+                            parent: execution,
+                        }),
+                    ])),
+                },
+            }
+            : {}),
+    });
+    const finish = (failed, error) => {
+        const outcome = failed ? quietly(() => runtime.outcomeOf(error), "failed") : "ok";
+        quietly(() => span.end(outcome, error), undefined);
+        if (outcome === "failed")
+            quietly(() => runtime.reporter?.report(error, {
+                useCase,
+                traceId: span.traceId,
+                executionId: id,
+                context,
+            }), undefined);
+    };
+    let answer;
+    try {
+        answer = body.apply(view, args);
+    }
+    catch (error) {
+        finish(true, error);
+        throw error;
+    }
+    if (answer instanceof Promise)
+        return answer.then((value) => {
+            finish(false);
+            return value;
+        }, (error) => {
+            finish(true, error);
+            throw error;
+        });
+    finish(false);
+    return answer;
+}

package/dist/services/runtime.d.ts

@@ -0,0 +1,48 @@
+import { type ErrorReporter, type Outcome, type Tracer } from "../observability/ports.js";
+/**
+ * What every use case of an application runs with: who traces, who reports, and the context
+ * each one carries to the server.
+ *
+ *     const runtime = createRuntime({
+ *       tracer,                                  // the platform's (OpenTelemetry, …)
+ *       reporter,                                // the platform's (GlitchTip, …)
+ *       context: () => ({ tenant_id: session.tenant }),
+ *     });
+ *     const project = bindServices(runtime, "project", { sendIssue, closeIssue });
+ *     await project.closeIssue.execute({ issue_id: "acme-3" });
+ *
+ * Context: sincpro_framework's bus is what gives every use case its span, its error report and
+ * its context; here the same comes from the interceptors of `Feature`, and this is what they
+ * read. A use case that was never bound runs too — with nothing tracing and nothing reporting —
+ * so a Feature is tested by constructing it.
+ */
+export type RuntimeOptions = {
+    tracer?: Tracer;
+    reporter?: ErrorReporter;
+    /**
+     * What a use case runs with, read once where a gesture starts and inherited by every use case
+     * it executes. It is what services read (`this.context`) and what travels to the server in
+     * `sincpro-context` — never a secret: the token goes in the transport's headers.
+     */
+    context?: () => Readonly<Record<string, unknown>>;
+    /** How an error ended a use case (`outcomeOf` by default). Only `failed` is reported. */
+    outcomeOf?: (error: unknown) => Outcome;
+};
+export type Runtime = {
+    readonly tracer: Tracer;
+    readonly reporter: ErrorReporter | undefined;
+    readonly context: () => Readonly<Record<string, unknown>>;
+    readonly outcomeOf: (error: unknown) => Outcome;
+};
+export declare function createRuntime(options?: RuntimeOptions): Runtime;
+/** Where a use case that was never bound runs: nothing traces, nothing reports. */
+export declare const DETACHED: Runtime;
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported.
+ */
+export declare function outcomeOf(error: unknown): Outcome;

package/dist/services/runtime.js

@@ -0,0 +1,30 @@
+import { TransportError } from "../client/transport.js";
+import { NO_TRACER, } from "../observability/ports.js";
+const NO_CONTEXT = Object.freeze({});
+export function createRuntime(options = {}) {
+    return {
+        tracer: options.tracer ?? NO_TRACER,
+        reporter: options.reporter,
+        context: options.context ?? (() => NO_CONTEXT),
+        outcomeOf: options.outcomeOf ?? outcomeOf,
+    };
+}
+/** Where a use case that was never bound runs: nothing traces, nothing reports. */
+export const DETACHED = createRuntime();
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported.
+ */
+export function outcomeOf(error) {
+    if (error instanceof TransportError && error.status !== null)
+        return error.status >= 400 && error.status < 500 ? "refused" : "failed";
+    if (error !== null &&
+        typeof error === "object" &&
+        error.name === "AbortError")
+        return "aborted";
+    return "failed";
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,35 @@
+import type { ErrorAbout, ErrorReporter, Outcome, Tracer } from "../observability/ports.js";
+/**
+ * A tracer and a reporter that keep what they were told, so a test reads it back.
+ *
+ *     const tracer = memoryTracer();
+ *     const project = bindServices(createRuntime({ tracer }), "project", { closeIssue });
+ *     await project.closeIssue.execute(input);
+ *     tracer.spans.map((one) => one.name);   // ["project/closeIssue", "project/send", …]
+ *
+ * Context: a use case is proven in Node with nothing of a platform; these are the platform's
+ * part, held in memory. Not test doubles of this package — real implementations of its ports.
+ */
+/** A span as the memory tracer kept it. */
+export type RecordedSpan = {
+    name: string;
+    traceId: string;
+    spanId: string;
+    /** The span it was opened under, when it was. */
+    parentSpanId: string | undefined;
+    attributes: Record<string, string | number | boolean>;
+    /** How it ended; `undefined` while it is open. */
+    outcome: Outcome | undefined;
+    error: unknown;
+};
+export type MemoryTracer = Tracer & {
+    readonly spans: RecordedSpan[];
+};
+export declare function memoryTracer(): MemoryTracer;
+export type MemoryReporter = ErrorReporter & {
+    readonly reports: {
+        error: unknown;
+        about: ErrorAbout;
+    }[];
+};
+export declare function memoryReporter(): MemoryReporter;

package/dist/testing/index.js

@@ -0,0 +1,37 @@
+function hex(bytes) {
+    return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export function memoryTracer() {
+    const spans = [];
+    return {
+        spans,
+        start(name, options) {
+            const recorded = {
+                name,
+                traceId: options.parent?.traceId || hex(16),
+                spanId: hex(8),
+                parentSpanId: options.parent?.spanId || undefined,
+                attributes: { ...options.attributes },
+                outcome: undefined,
+                error: undefined,
+            };
+            spans.push(recorded);
+            return {
+                traceId: recorded.traceId,
+                spanId: recorded.spanId,
+                sampled: true,
+                set: (attributes) => void Object.assign(recorded.attributes, attributes),
+                end: (outcome, error) => {
+                    if (recorded.outcome !== undefined)
+                        return;
+                    recorded.outcome = outcome;
+                    recorded.error = error;
+                },
+            };
+        },
+    };
+}
+export function memoryReporter() {
+    const reports = [];
+    return { reports, report: (error, about) => void reports.push({ error, about }) };
+}

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@sincpro/client-framework",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The client side of sincpro_framework, for every platform: Feature and ApplicationService traced and reported by default, applications made of domains, and the typed client generated from a service's contract. No React, no DOM.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./codegen": {
+      "types": "./dist/codegen/index.d.ts",
+      "default": "./dist/codegen/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "bin": {
+    "sincpro-client": "./dist/codegen/cli.js"
+  },
+  "files": [
+    "dist",
+    "MANIFESTO.md",
+    "AGENTS.md",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "sincpro",
+    "sincpro-framework",
+    "ddd",
+    "use-case",
+    "feature",
+    "application-service",
+    "opentelemetry",
+    "codegen"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sincpro-SRL/sincpro_client_framework.git"
+  },
+  "homepage": "https://github.com/Sincpro-SRL/sincpro_client_framework#readme",
+  "bugs": {
+    "url": "https://github.com/Sincpro-SRL/sincpro_client_framework/issues"
+  },
+  "author": "Gutierrez, Andres <andres.gutierrez@sincpro.com.bo>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=26"
+  },
+  "prettier": {
+    "printWidth": 94
+  },
+  "peerDependencies": {
+    "@sincpro/criteria": "^1.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@sincpro/criteria": "^1.1.0",
+    "@types/node": "^26.6.6",
+    "eslint": "^10.14.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "prettier": "^3.9.10",
+    "tsc-alias": "^1.9.9",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.72.1",
+    "vite": "8.3.5",
+    "vitest": "5.0.5"
+  }
+}