@makaio/framework 1.0.0-dev-1781022866275 → 1.0.0-dev-1781023871421

package/dist/core/index.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";function t(e){if(typeof e!=`object`||!e)return!1;let t=e;return`$in`in t||`$ne`in t||`$exists`in t||`$startsWith`in t||`$endsWith`in t}const n=`*`;function r(t){return typeof t==`object`&&!!t&&`request`in t&&`response`in t&&t.request instanceof e.ZodType&&t.response instanceof e.ZodType}function i(e){return typeof e==`object`&&!!e&&`__channel`in e&&e.__channel===!0&&`schema`in e}function a(e){return{__channel:!0,schema:e}}function o(e){return typeof e==`object`&&!!e&&`__local`in e&&e.__local===!0&&`schema`in e}function s(e){return{__local:!0,schema:e}}function c(e){return typeof e==`object`&&!!e&&`__defaultTransports`in e&&(e.__defaultTransports===`all`||e.__defaultTransports===`local-only`)&&`schema`in e}function l(e,t){return{__defaultTransports:t,schema:e}}function u(e){return typeof e==`object`&&!!e&&`__collectorOnly`in e&&e.__collectorOnly===!0&&`schema`in e}function d(e){return{__collectorOnly:!0,schema:e}}function f(e){return o(e)||u(e)||i(e)||c(e)?e.schema:e}function p(e,t,n){let a={};for(let[s,l]of Object.entries(t)){let t=s.split(`.`),u=a;for(let e=0;e<t.length-1;e++)u[t[e]]??={},u=u[t[e]];let d=o(l),p=i(l),m=c(l)?l.__defaultTransports:n,h={subject:s,$meta:{namespace:e,isRequest:r(f(l)),local:d,channel:p,...m!==void 0&&{defaultTransports:m}}};u[t[t.length-1]]=h}return a.$all={subject:`*`,$meta:{namespace:e,isRequest:!1,local:!1,channel:!1}},a}function m(e){return`${e.$meta.namespace}.${e.subject}`}function h(e,t,n){let r=n?.defaultTransports,i;if(n!==void 0){let{defaultTransports:e,...t}=n;i=Object.keys(t).length>0?t:void 0}return{name:e,subjects:p(e,t,r),schemas:t,...i===void 0?{}:{options:i},...r===void 0?{}:{defaultTransports:r}}}e.object({cwd:e.string(),env:e.record(e.string(),e.string()),platform:e.enum([`posix`,`windows`]),signal:e.custom().optional(),constraints:e.record(e.string(),e.unknown()).optional(),sessionId:e.string().optional(),subagentId:e.string().optional(),subagentDepth:e.number().optional()});function g(){return typeof process>`u`?`posix`:process.platform===`win32`?`windows`:`posix`}const _=[`API_KEY`,`APIKEY`,`SECRET`,`TOKEN`,`PASSWORD`,`CREDENTIAL`,`PRIVATE_KEY`,`PRIVATEKEY`,`AUTH`,`BEARER`,`ACCESS_KEY`,`ACCESSKEY`];function v(e){let t=e.toUpperCase();return _.some(e=>t.includes(e))}function y(e){let t={};for(let[n,r]of Object.entries(e))r!==void 0&&!v(n)&&(t[n]=r);return t}function b(e){let t=typeof process<`u`?process.cwd():`/`,n=typeof process<`u`?y(process.env):{};return{cwd:e?.cwd??t,env:e?.env??n,platform:e?.platform??g(),signal:e?.signal,constraints:e?.constraints,sessionId:e?.sessionId,subagentId:e?.subagentId,subagentDepth:e?.subagentDepth}}var x=class extends Error{subject;constructor(e,t){super(e),this.subject=t,this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}},S=class extends x{subject;constructor(e,t){super(`Invalid model specified: ${e}`),this.subject=t,this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}},C=class extends x{subject;constructor(e,t){super(`Directory does not exist: ${e}`),this.subject=t,this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}},w=class extends x{subject;constructor(e,t){super(e),this.subject=t,this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}},T=class extends x{code=`rate_limit`},E=class extends x{code=`auth`},D=class extends x{code=`model_unavailable`},O=class extends x{code=`quota_exceeded`};const k=`makaio.observability`;function A(e){let t=e.meta()?.[k];if(typeof t!=`object`||!t)return;let n=t;return n.kind===`schema`||n.kind===`field`?n:void 0}function j(e,t){return e.meta({...e.meta(),[k]:t})}function M(t){if(t instanceof e.ZodOptional||t instanceof e.ZodNullable||t instanceof e.ZodDefault||t instanceof e.ZodCatch||t instanceof e.ZodReadonly)return t.unwrap()}function N(e){let t=e;for(;t;){let e=A(t);if(e?.kind===`field`)return e;t=M(t)}}function P(e){let t=A(e);if(t?.kind===`schema`)return{traceAll:t.traceAll}}function F(e){let t=N(e);if(t)return{visibility:t.visibility,attributeName:t.attributeName}}const I={schema(e,t){return j(e,{kind:`schema`,traceAll:t.traceAll})},field(e,t){return j(e,{kind:`field`,visibility:t.visibility,attributeName:t.attributeName})},hidden(e){return j(e,{kind:`field`,visibility:`hidden`})},count(e,t){return j(e,{kind:`field`,visibility:`count`,attributeName:t})},attribute(e,t){return j(e,{kind:`field`,visibility:`attribute`,attributeName:t})}};export{E as AuthenticationError,w as ConfigError,C as DirectoryNotFoundError,S as InvalidModelError,x as MakaioError,D as ModelUnavailableError,k as OBSERVABILITY_META_KEY,O as QuotaExceededError,T as RateLimitError,n as WildcardSubjectKey,a as channelSubject,d as collectorOnlySubject,h as createBusNamespace,b as createMakaioContext,l as defaultTransports,m as getFullSubjectForSubjectDefinition,F as getObservabilityFieldPolicy,P as getObservabilitySchemaPolicy,i as isChannelSchema,u as isCollectorOnlySchema,c as isDefaultTransportsSchema,o as isLocalSchema,t as isOperatorObject,r as isRequestSchema,s as localSubject,p as nestSubjectDefinitions,I as observability,f as unwrapSchema};

package/dist/credential-ref-YWQQENEo.mjs

@@ -0,0 +1 @@
+import"./visibility-Cb62p9bv.mjs";import{z as e}from"zod";const t=`stored:providerConfig:`,n=`account-manager:`;function r(e){if(!e.startsWith(t))return null;let n=e.slice(22),r=n.lastIndexOf(`:`);if(r===-1)return null;let i=n.slice(0,r),a=n.slice(r+1);return!i||!a||a.includes(`:`)?null:{configId:i,key:a}}function i(e,t){if(!e.startsWith(t))return!1;let n=e.slice(t.length),r=n.indexOf(`:`);return!(r<=0||r>=n.length-1)}function a(e){if(!e.startsWith(n))return null;try{let t=JSON.parse(e.slice(16));return!Array.isArray(t)||t.length!==2||typeof t[0]!=`string`||typeof t[1]!=`string`||t[0].length===0||t[1].length===0?null:{clientId:t[0],accountId:t[1]}}catch{return null}}function o(e){if(r(e))return!0;if(e.startsWith(`env:`)){let t=e.slice(4);return/^[A-Za-z_][A-Za-z0-9_]*$/.test(t)}return e.startsWith(`file:`)?e.length>5:!!(i(e,`keychain:`)||a(e))}function s(e){return a(e)!==null}const c=e.string().refine(o,{message:`Invalid credential reference format.`}).brand();function l(e,n){if(n.includes(`:`))throw Error(`Credential key must not contain colons: "${n}"`);return c.parse(`${t}${e}:${n}`)}function u(e,t){return c.parse(`${n}${JSON.stringify([e,t])}`)}function d(e){return r(e)}function f(e){if(!e)return;let t={};for(let[n,r]of Object.entries(e))t[n]=c.parse(r);return t}function p(e){if(e)return Object.fromEntries(Object.entries(e).map(([e,t])=>[e,t]))}export{s as a,l as i,f as n,d as o,u as r,p as s,c as t};

package/dist/cursor-storage-CtVJ3JzB.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";import{createStorageNamespaceDefinition as t}from"@makaio/framework/storage";const n=new WeakMap,r=new WeakMap,i=new WeakMap,a=Symbol(`anyProducer`),o=Promise.resolve(),s=Symbol(`listenerAdded`),c=Symbol(`listenerRemoved`);let l=!1,u=!1;const d=e=>typeof e==`string`||typeof e==`symbol`||typeof e==`number`;function f(e){if(!d(e))throw TypeError("`eventName` must be a string, symbol, or number")}function p(e){if(typeof e!=`function`)throw TypeError(`listener must be a function`)}function m(e,t){let n=r.get(e);if(n.has(t))return n.get(t)}function h(e,t){let n=d(t)?t:a,r=i.get(e);if(r.has(n))return r.get(n)}function g(e,t,n){let r=i.get(e);if(r.has(t))for(let e of r.get(t))e.enqueue(n);if(r.has(a)){let e=Promise.all([t,n]);for(let t of r.get(a))t.enqueue(e)}}function _(e,t){t=Array.isArray(t)?t:[t];let n=!1,r=()=>{},a=[],o={enqueue(e){a.push(e),r()},finish(){n=!0,r()}};for(let n of t){let t=h(e,n);t||(t=new Set,i.get(e).set(n,t)),t.add(o)}return{async next(){return a?a.length===0?n?(a=void 0,this.next()):(await new Promise(e=>{r=e}),this.next()):{done:!1,value:await a.shift()}:{done:!0}},async return(n){a=void 0;for(let n of t){let t=h(e,n);t&&(t.delete(o),t.size===0&&i.get(e).delete(n))}return r(),arguments.length>0?{done:!0,value:await n}:{done:!0}},[Symbol.asyncIterator](){return this}}}function v(e){if(e===void 0)return S;if(!Array.isArray(e))throw TypeError("`methodNames` must be an array of strings");for(let t of e)if(!S.includes(t))throw typeof t==`string`?Error(`${t} is not Emittery method`):TypeError("`methodNames` element must be a string");return e}const y=e=>e===s||e===c;function b(e,t,n){if(y(t))try{l=!0,e.emit(t,n)}finally{l=!1}}var x=class e{static mixin(t,n){return n=v(n),r=>{if(typeof r!=`function`)throw TypeError("`target` must be function");for(let e of n)if(r.prototype[e]!==void 0)throw Error(`The property \`${e}\` already exists on \`target\``);function i(){return Object.defineProperty(this,t,{enumerable:!1,value:new e}),this[t]}Object.defineProperty(r.prototype,t,{enumerable:!1,get:i});let a=e=>function(...n){return this[t][e](...n)};for(let e of n)Object.defineProperty(r.prototype,e,{enumerable:!1,value:a(e)});return r}}static get isDebugEnabled(){if(typeof globalThis.process?.env!=`object`)return u;let{env:e}=globalThis.process??{env:{}};return e.DEBUG===`emittery`||e.DEBUG===`*`||u}static set isDebugEnabled(e){u=e}constructor(e={}){n.set(this,new Set),r.set(this,new Map),i.set(this,new Map),i.get(this).set(a,new Set),this.debug=e.debug??{},this.debug.enabled===void 0&&(this.debug.enabled=!1),this.debug.logger||(this.debug.logger=(e,t,n,r)=>{try{r=JSON.stringify(r)}catch{r=`Object with the following keys failed to stringify: ${Object.keys(r).join(`,`)}`}(typeof n==`symbol`||typeof n==`number`)&&(n=n.toString());let i=new Date,a=`${i.getHours()}:${i.getMinutes()}:${i.getSeconds()}.${i.getMilliseconds()}`;console.log(`[${a}][emittery:${e}][${t}] Event Name: ${n}\n\tdata: ${r}`)})}logIfDebugEnabled(t,n,r){(e.isDebugEnabled||this.debug.enabled)&&this.debug.logger(t,this.debug.name,n,r)}on(e,t,{signal:n}={}){p(t),e=Array.isArray(e)?e:[e];for(let n of e){f(n);let e=m(this,n);e||(e=new Set,r.get(this).set(n,e)),e.add(t),this.logIfDebugEnabled(`subscribe`,n,void 0),y(n)||b(this,s,{eventName:n,listener:t})}let i=()=>{this.off(e,t),n?.removeEventListener(`abort`,i)};return n?.addEventListener(`abort`,i,{once:!0}),n?.aborted&&i(),i}off(e,t){p(t),e=Array.isArray(e)?e:[e];for(let n of e){f(n);let e=m(this,n);e&&(e.delete(t),e.size===0&&r.get(this).delete(n)),this.logIfDebugEnabled(`unsubscribe`,n,void 0),y(n)||b(this,c,{eventName:n,listener:t})}}once(e,t){if(t!==void 0&&typeof t!=`function`)throw TypeError(`predicate must be a function`);let n,r=new Promise(r=>{n=this.on(e,e=>{t&&!t(e)||(n(),r(e))})});return r.off=n,r}events(e){e=Array.isArray(e)?e:[e];for(let t of e)f(t);return _(this,e)}async emit(e,t){if(f(e),y(e)&&!l)throw TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");this.logIfDebugEnabled(`emit`,e,t),g(this,e,t);let r=m(this,e)??new Set,i=n.get(this),a=[...r],s=y(e)?[]:[...i];await o,await Promise.all([...a.map(async e=>{if(r.has(e))return e(t)}),...s.map(async n=>{if(i.has(n))return n(e,t)})])}async emitSerial(e,t){if(f(e),y(e)&&!l)throw TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");this.logIfDebugEnabled(`emitSerial`,e,t),g(this,e,t);let r=m(this,e)??new Set,i=n.get(this),a=[...r],s=y(e)?[]:[...i];await o;for(let e of a)r.has(e)&&await e(t);for(let n of s)i.has(n)&&await n(e,t)}onAny(e,{signal:t}={}){p(e),this.logIfDebugEnabled(`subscribeAny`,void 0,void 0),n.get(this).add(e),b(this,s,{listener:e});let r=()=>{this.offAny(e),t?.removeEventListener(`abort`,r)};return t?.addEventListener(`abort`,r,{once:!0}),t?.aborted&&r(),r}anyEvent(){return _(this)}offAny(e){p(e),this.logIfDebugEnabled(`unsubscribeAny`,void 0,void 0),b(this,c,{listener:e}),n.get(this).delete(e)}clearListeners(e){e=Array.isArray(e)?e:[e];for(let t of e)if(this.logIfDebugEnabled(`clear`,t,void 0),d(t)){let e=m(this,t);e&&e.clear();let n=h(this,t);if(n){for(let e of n)e.finish();n.clear()}}else{n.get(this).clear();for(let[e,t]of r.get(this).entries())t.clear(),r.get(this).delete(e);for(let[e,t]of i.get(this).entries()){for(let e of t)e.finish();t.clear(),i.get(this).delete(e)}}}listenerCount(e){e=Array.isArray(e)?e:[e];let t=0;for(let a of e){if(d(a)){t+=n.get(this).size+(m(this,a)?.size??0)+(h(this,a)?.size??0)+(h(this)?.size??0);continue}a!==void 0&&f(a),t+=n.get(this).size;for(let e of r.get(this).values())t+=e.size;for(let e of i.get(this).values())t+=e.size}return t}bindMethods(e,t){if(typeof e!=`object`||!e)throw TypeError("`target` must be an object");t=v(t);for(let n of t){if(e[n]!==void 0)throw Error(`The property \`${n}\` already exists on \`target\``);Object.defineProperty(e,n,{enumerable:!1,value:this[n].bind(this)})}}};const S=Object.getOwnPropertyNames(x.prototype).filter(e=>e!==`constructor`);Object.defineProperty(x,`listenerAdded`,{value:s,writable:!1,enumerable:!0,configurable:!1}),Object.defineProperty(x,`listenerRemoved`,{value:c,writable:!1,enumerable:!0,configurable:!1});const C=e.custom(()=>!0),w=e.object({filePath:e.string(),bytesRead:e.number(),lastModified:e.string(),sessionContext:C.optional()}),T=t(`importCursor`,{schemas:{get:{request:e.object({filePath:e.string()}),response:e.object({cursor:w.nullable()})},set:{request:w,response:e.object({success:e.boolean()})},delete:{request:e.object({filePath:e.string()}),response:e.object({success:e.boolean()})}}}),E=T.subjects;export{x as i,T as n,E as r,w as t};

package/dist/definition-BLCdXGzh.d.mts

@@ -0,0 +1,383 @@
+import { z } from "zod";
+
+//#region core/contracts/src/version/primitives.d.ts
+/**
+ * npm semver range syntax (e.g. `">=1.0.0 <2.0.0"`, `"^1.5.0"`).
+ *
+ * Used by all range-bearing compatibility fields in descriptors and manifests.
+ */
+type VersionRange = string;
+/**
+ * Exact semver version (e.g. `"1.0.72"`).
+ *
+ * Used for concrete version pins such as preferred binary versions.
+ */
+type VersionLiteral = string;
+/** Validates that the string is a valid npm semver range. */
+declare const VersionRangeSchema: z.ZodString;
+/**
+ * Check whether a concrete version satisfies a semver range.
+ *
+ * Centralizes the `{ includePrerelease: true }` policy so every compatibility
+ * check in the framework uses the same semantics.
+ * @param version - Concrete semver version string.
+ * @param range - npm semver range to test against.
+ * @returns `true` when the version falls within the range.
+ */
+declare function versionSatisfies(version: string, range: VersionRange): boolean;
+/**
+ * Check whether a semver range is a universal wildcard (`*`, `>=0.0.0`, etc.).
+ *
+ * Uses the `semver` library's normalization so all universal range syntaxes are
+ * recognized, not just the literal `'*'` string.
+ * @param range - Semver range to test.
+ * @returns `true` when the range matches any version.
+ */
+declare function isUniversalRange(range: string): boolean;
+/** Validates that the string is an exact semver version. */
+declare const VersionLiteralSchema: z.ZodString;
+//#endregion
+//#region core/contracts/src/client/definition.d.ts
+/**
+ * Schema for a capability annotation attached to a native client tool.
+ *
+ * Captures a capability tag (e.g. `'shell.execute'`) and an optional
+ * human-readable description so the Harness UI can explain what a tool does
+ * without coupling to the platform capability taxonomy.
+ */
+declare const ClientToolCapabilityAnnotationSchema: z.ZodObject<{
+  tag: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ClientToolCapabilityAnnotation = z.infer<typeof ClientToolCapabilityAnnotationSchema>;
+/**
+ * Schema for a single native tool provided by a client binary.
+ *
+ * Native tools are those the client binary exposes directly (e.g. `bash`,
+ * `file_edit`). They are declared by the client package and seeded into
+ * the harness at startup.
+ */
+declare const ClientToolDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  friendlyName: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  category: z.ZodOptional<z.ZodString>;
+  capabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    tag: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ClientToolDefinition = z.infer<typeof ClientToolDefinitionSchema>;
+/**
+ * Schema for a log source definition contributed by a client package.
+ *
+ * Log sources describe where the client binary writes conversation logs so the
+ * Makaio log-import service can discover and ingest them.
+ */
+declare const LogSourceDefinitionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  glob: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type LogSourceDefinition = z.infer<typeof LogSourceDefinitionSchema>;
+/**
+ * Schema for a hook event declaration on a client definition.
+ *
+ * Declares which native hook events the client binary fires. Used by the
+ * wiring layer to know what hooks to install, and by the UI to display
+ * available events.
+ */
+declare const ClientHookEventDeclarationSchema: z.ZodObject<{
+  name: z.ZodString;
+  frameworkSubject: z.ZodOptional<z.ZodString>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    request: "request";
+    event: "event";
+  }>>;
+}, z.core.$strip>;
+type ClientHookEventDeclaration = z.infer<typeof ClientHookEventDeclarationSchema>;
+/**
+ * Schema for the config isolation descriptor on a client definition.
+ *
+ * Describes the environment variable and default path the client binary uses
+ * for config isolation. Most clients accept a directory path. Some clients only
+ * expose a file-level override, so `pathKind` records which value shape the env
+ * var expects.
+ */
+declare const ConfigIsolationSchema: z.ZodObject<{
+  envVar: z.ZodString;
+  defaultPath: z.ZodString;
+  pathKind: z.ZodDefault<z.ZodEnum<{
+    file: "file";
+    directory: "directory";
+  }>>;
+}, z.core.$strip>;
+type ConfigIsolation = z.infer<typeof ConfigIsolationSchema>;
+/**
+ * Install descriptor for the `npm` strategy.
+ *
+ * The manager runs a sandboxed `npm install --prefix <targetDir>` for the
+ * pinned package version so managed installs do not mutate global npm state.
+ * An exact version pin is required; floating ranges are not accepted so the
+ * framework can reproduce the same binary across machines and time.
+ */
+declare const NpmInstallDescriptorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"npm">;
+  package: z.ZodString;
+  version: z.ZodString;
+}, z.core.$strip>;
+type NpmInstallDescriptor = z.infer<typeof NpmInstallDescriptorSchema>;
+/**
+ * Install descriptor for the `signed-binary-bucket` strategy.
+ *
+ * The manager fetches a GPG-signed manifest from a versioned bucket path,
+ * verifies the manifest signature against the declared public key, selects the
+ * per-platform binary, downloads it, and verifies its checksum before
+ * activating the install.
+ *
+ * All bucket paths are Go-style templates: `{version}` is replaced with the
+ * resolved version string and `{platform}` / `{binary}` are replaced with the
+ * per-platform values from the `platforms` map.
+ */
+declare const SignedBinaryBucketInstallDescriptorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"signed-binary-bucket">;
+  version: z.ZodString;
+  config: z.ZodObject<{
+    baseUrl: z.ZodString;
+    manifestPathTemplate: z.ZodString;
+    manifestSignaturePathTemplate: z.ZodString;
+    publicKeyUrl: z.ZodString;
+    publicKeyFingerprint: z.ZodString;
+    binaryPathTemplate: z.ZodString;
+    platforms: z.ZodRecord<z.ZodString, z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type SignedBinaryBucketInstallDescriptor = z.infer<typeof SignedBinaryBucketInstallDescriptorSchema>;
+/**
+ * Discriminated union of all supported managed install descriptors.
+ *
+ * Two strategies are supported:
+ * - `npm`                  — npm registry installation with an exact version pin.
+ * - `signed-binary-bucket` — signed static bucket download with an exact version pin.
+ *
+ * The descriptor is purely declarative; no runtime logic lives here.
+ */
+declare const ManagedInstallDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"npm">;
+  package: z.ZodString;
+  version: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"signed-binary-bucket">;
+  version: z.ZodString;
+  config: z.ZodObject<{
+    baseUrl: z.ZodString;
+    manifestPathTemplate: z.ZodString;
+    manifestSignaturePathTemplate: z.ZodString;
+    publicKeyUrl: z.ZodString;
+    publicKeyFingerprint: z.ZodString;
+    binaryPathTemplate: z.ZodString;
+    platforms: z.ZodRecord<z.ZodString, z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type ManagedInstallDescriptor = z.infer<typeof ManagedInstallDescriptorSchema>;
+/**
+ * Platform-aware command descriptor for querying the installed binary version.
+ *
+ * The `executable` field may be a single relative path string (used on all
+ * platforms) or a platform-keyed object that overrides the `default` executable
+ * on specific operating systems.
+ *
+ * All executable values are resolved relative to the managed install directory
+ * — absolute paths and parent-directory traversals (`..`) are rejected by the
+ * `ClientDefinitionSchema` refinement.
+ */
+declare const VersionCommandSchema: z.ZodObject<{
+  executable: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    default: z.ZodString;
+    darwin: z.ZodOptional<z.ZodString>;
+    linux: z.ZodOptional<z.ZodString>;
+    win32: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>;
+  args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type VersionCommand = z.infer<typeof VersionCommandSchema>;
+/**
+ * Optional post-install action descriptor.
+ *
+ * Carries an open-ended `kind` string so the runtime can dispatch to a
+ * registered post-install handler without the contracts layer enumerating
+ * every possible action.
+ */
+declare const PostInstallDescriptorSchema: z.ZodObject<{
+  kind: z.ZodString;
+  payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type PostInstallDescriptor = z.infer<typeof PostInstallDescriptorSchema>;
+/**
+ * Declarative runtime capability flags for a client package.
+ *
+ * These flags are static declarations contributed by the client package.
+ * They inform Makaio which observation and launch mechanisms the client
+ * supports so the framework can activate the appropriate producers and
+ * adapt its behaviour without runtime probing.
+ *
+ * All flags default to `false` so packages only need to opt in to what they
+ * actually support.
+ */
+declare const ClientRuntimeCapabilitiesSchema: z.ZodObject<{
+  supportsHooks: z.ZodDefault<z.ZodBoolean>;
+  supportsStatusline: z.ZodDefault<z.ZodBoolean>;
+  supportsSupervisorLaunch: z.ZodDefault<z.ZodBoolean>;
+  supportsManagedBinary: z.ZodDefault<z.ZodBoolean>;
+  hookEvents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    frameworkSubject: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+      request: "request";
+      event: "event";
+    }>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ClientRuntimeCapabilities = z.infer<typeof ClientRuntimeCapabilitiesSchema>;
+/**
+ * Binary compatibility descriptor for a client definition.
+ *
+ * Groups all binary-related compatibility information: the executable name
+ * used for PATH detection and the version range the framework supports.
+ */
+interface ClientBinaryCompatibility {
+  /** Binary name used for CLI detection (e.g. `'claude'` for the `claude` binary on `PATH`). */
+  readonly name: string;
+  /**
+   * npm semver range of supported binary versions
+   * (e.g. `'>=1.0.0'`, `'^2.0.0'`).
+   */
+  readonly supportedVersions: VersionRange;
+}
+/** Zod schema for {@link ClientBinaryCompatibility}. */
+declare const ClientBinaryCompatibilitySchema: z.ZodObject<{
+  name: z.ZodString;
+  supportedVersions: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Static definition for a Makaio client package.
+ *
+ * Each client package (e.g. `@makaio/client-claude-code`) exports exactly one
+ * `ClientDefinition` object. The bootstrap service discovers and seeds these
+ * definitions into the `clients` storage table on startup.
+ *
+ * Key fields:
+ * - `runtimeCapabilities` — capability flags (hooks, managed binary, etc.)
+ * - `managedInstall` — install descriptor when Makaio manages the binary.
+ * - `configIsolation` — env var and default path for config isolation.
+ *   Used by both managed and global binaries; see {@link ConfigIsolationSchema}.
+ */
+declare const ClientDefinitionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  binary: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    supportedVersions: z.ZodString;
+  }, z.core.$strict>>;
+  nativeTools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    friendlyName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      tag: z.ZodString;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>>;
+  defaultApprovalPolicy: z.ZodEnum<{
+    reject: "reject";
+    "always-ask": "always-ask";
+    "full-access": "full-access";
+  }>;
+  logSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  defaultProviderId: z.ZodOptional<z.ZodString>;
+  runtimeCapabilities: z.ZodPipe<z.ZodOptional<z.ZodObject<{
+    supportsHooks: z.ZodDefault<z.ZodBoolean>;
+    supportsStatusline: z.ZodDefault<z.ZodBoolean>;
+    supportsSupervisorLaunch: z.ZodDefault<z.ZodBoolean>;
+    supportsManagedBinary: z.ZodDefault<z.ZodBoolean>;
+    hookEvents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      frameworkSubject: z.ZodOptional<z.ZodString>;
+      mode: z.ZodDefault<z.ZodEnum<{
+        request: "request";
+        event: "event";
+      }>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>, z.ZodTransform<{
+    supportsHooks: boolean;
+    supportsStatusline: boolean;
+    supportsSupervisorLaunch: boolean;
+    supportsManagedBinary: boolean;
+    hookEvents: {
+      name: string;
+      mode: "request" | "event";
+      frameworkSubject?: string | undefined;
+    }[];
+  }, {
+    supportsHooks: boolean;
+    supportsStatusline: boolean;
+    supportsSupervisorLaunch: boolean;
+    supportsManagedBinary: boolean;
+    hookEvents: {
+      name: string;
+      mode: "request" | "event";
+      frameworkSubject?: string | undefined;
+    }[];
+  } | undefined>>;
+  managedInstall: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"npm">;
+    package: z.ZodString;
+    version: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"signed-binary-bucket">;
+    version: z.ZodString;
+    config: z.ZodObject<{
+      baseUrl: z.ZodString;
+      manifestPathTemplate: z.ZodString;
+      manifestSignaturePathTemplate: z.ZodString;
+      publicKeyUrl: z.ZodString;
+      publicKeyFingerprint: z.ZodString;
+      binaryPathTemplate: z.ZodString;
+      platforms: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>], "type">>;
+  versionCommand: z.ZodOptional<z.ZodObject<{
+    executable: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      default: z.ZodString;
+      darwin: z.ZodOptional<z.ZodString>;
+      linux: z.ZodOptional<z.ZodString>;
+      win32: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>;
+  postInstall: z.ZodOptional<z.ZodObject<{
+    kind: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  configIsolation: z.ZodOptional<z.ZodObject<{
+    envVar: z.ZodString;
+    defaultPath: z.ZodString;
+    pathKind: z.ZodDefault<z.ZodEnum<{
+      file: "file";
+      directory: "directory";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strict>;
+type ClientDefinitionInput = z.input<typeof ClientDefinitionSchema>;
+type ClientDefinition = z.infer<typeof ClientDefinitionSchema>;
+//#endregion
+export { VersionRange as A, PostInstallDescriptorSchema as C, VersionCommandSchema as D, VersionCommand as E, isUniversalRange as M, versionSatisfies as N, VersionLiteral as O, PostInstallDescriptor as S, SignedBinaryBucketInstallDescriptorSchema as T, LogSourceDefinitionSchema as _, ClientDefinitionSchema as a, NpmInstallDescriptor as b, ClientRuntimeCapabilities as c, ClientToolCapabilityAnnotationSchema as d, ClientToolDefinition as f, LogSourceDefinition as g, ConfigIsolationSchema as h, ClientDefinitionInput as i, VersionRangeSchema as j, VersionLiteralSchema as k, ClientRuntimeCapabilitiesSchema as l, ConfigIsolation as m, ClientBinaryCompatibilitySchema as n, ClientHookEventDeclaration as o, ClientToolDefinitionSchema as p, ClientDefinition as r, ClientHookEventDeclarationSchema as s, ClientBinaryCompatibility as t, ClientToolCapabilityAnnotation as u, ManagedInstallDescriptor as v, SignedBinaryBucketInstallDescriptor as w, NpmInstallDescriptorSchema as x, ManagedInstallDescriptorSchema as y };

package/dist/definition-CrgHIpTK.d.mts

@@ -0,0 +1,60 @@
+import { l as SurfaceBindingRegistration } from "./schemas-wg_6PAdV.mjs";
+
+//#region core/contracts/src/materialization/definition.d.ts
+/**
+ * A surface binding definition with a serializable registration record.
+ *
+ * Created by {@link defineSurfaceBinding}. The definition retains the original
+ * options and produces a bus-transportable {@link SurfaceBindingRegistration}
+ * via `toRegistration()`.
+ *
+ * The interface is intentionally opaque: only `id` is exposed directly so
+ * that callers have a stable, lightweight handle. All other properties are
+ * accessible exclusively through `toRegistration()`, keeping the contract
+ * aligned with the bus registration shape.
+ */
+interface SurfaceBindingDefinition {
+  /** Stable identifier for this surface binding (e.g. `'github.status.field'`). */
+  readonly id: string;
+  /**
+   * Produces a serializable registration record suitable for bus transport.
+   * @returns A {@link SurfaceBindingRegistration} snapshot with `target`
+   *   deep-cloned and all array fields copied to prevent shared-reference
+   *   mutation.
+   */
+  readonly toRegistration: () => SurfaceBindingRegistration;
+}
+/**
+ * Options for {@link defineSurfaceBinding}.
+ *
+ * Structurally identical to {@link SurfaceBindingRegistration} — every field
+ * is included in the serializable registration output.
+ */
+type DefineSurfaceBindingOptions = SurfaceBindingRegistration;
+/**
+ * Creates a surface binding definition with a serializable registration.
+ *
+ * The returned definition exposes the `id` identifier directly and produces
+ * a bus-transportable {@link SurfaceBindingRegistration} via `toRegistration()`.
+ * The `target` object is deep-cloned via `structuredClone` (consistent with
+ * how {@link SurfaceBindingRegistry} clones at storage boundaries), and array
+ * fields (`appliesTo`) are defensively copied so callers cannot mutate the
+ * registration snapshot.
+ * @param options - Surface binding registration options including provider,
+ *   namespace, target, and entity classes the binding applies to.
+ * @returns A {@link SurfaceBindingDefinition} with a `toRegistration` method.
+ * @example
+ * ```ts
+ * export const githubStatusFieldBinding = defineSurfaceBinding({
+ *   id: 'github.status.field',
+ *   provider: 'github',
+ *   namespace: 'status',
+ *   target: { kind: 'field', name: 'Status' },
+ *   appliesTo: ['workpiece'],
+ *   valueMapping: { pending: 'In Progress', completed: 'Done' },
+ * });
+ * ```
+ */
+declare function defineSurfaceBinding(options: DefineSurfaceBindingOptions): SurfaceBindingDefinition;
+//#endregion
+export { defineSurfaceBinding as n, SurfaceBindingDefinition as t };

package/dist/definition-DZMXOnjX.mjs

@@ -0,0 +1 @@
+import{i as e,t}from"./visibility-Cb62p9bv.mjs";import{z as n}from"zod";const r=n.enum([`anthropic`,`openai`]),i=n.object({anthropic:n.string().url(),openai:n.string().url()}).partial().refine(e=>Object.keys(e).length>0,{message:`At least one protocol endpoint must be specified`}),a=n.object({id:n.string().min(1),name:n.string().min(1),description:n.string().optional(),endpoints:i.optional(),defaultModel:n.string().optional(),fastModel:n.string().optional(),primaryTestModel:n.string().optional(),secondaryTestModel:n.string().optional(),availableModels:n.array(e).default([]),defaultModelFilterMode:t.optional(),credentialEnvVars:n.record(n.string(),n.string()).optional()});export{r as n,a as r,i as t};

package/dist/definition-pkJ6szUl.d.mts

@@ -0,0 +1,158 @@
+import { z } from "zod";
+
+//#region core/contracts/src/provider/definition.d.ts
+/**
+ * Wire protocol identifiers supported by Makaio adapters.
+ *
+ * Each value corresponds to an inference wire protocol:
+ * - `'anthropic'` — Anthropic Messages API (streaming via SSE)
+ * - `'openai'`    — OpenAI Chat Completions API (streaming via SSE)
+ */
+declare const ProtocolIdSchema: z.ZodEnum<{
+  anthropic: "anthropic";
+  openai: "openai";
+}>;
+/**
+ * Inferred union type for supported wire protocols.
+ */
+type ProtocolId = z.infer<typeof ProtocolIdSchema>;
+/**
+ * Maps wire protocol identifiers to their base endpoint URLs.
+ *
+ * A provider may support multiple protocols simultaneously — for example,
+ * Z.AI exposes both an Anthropic-compatible and an OpenAI-compatible endpoint.
+ * Omit a protocol key when the provider does not support it.
+ * @example Z.AI dual-protocol provider
+ * ```ts
+ * {
+ *   anthropic: 'https://api.z.ai/v1/anthropic',
+ *   openai: 'https://api.z.ai/v1/openai',
+ * }
+ * ```
+ */
+declare const ProtocolEndpointsSchema: z.ZodObject<{
+  anthropic: z.ZodOptional<z.ZodString>;
+  openai: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Inferred type for a protocol-to-endpoint mapping.
+ */
+type ProtocolEndpoints = z.infer<typeof ProtocolEndpointsSchema>;
+/**
+ * Provider definition schema.
+ *
+ * The canonical parsed provider contract. Defines the stable identity,
+ * display metadata, protocol endpoints, runtime-populated model catalog, and
+ * credential environment variables for a single inference provider.
+ *
+ * Static provider packages should declare {@link ProviderDefinitionInput}:
+ * they describe what a provider *is*, not how it is configured at runtime.
+ * The runtime layer (storage, sync service, model registry) derives parsed
+ * provider definitions and per-user provider records from those declarations.
+ *
+ * Providers that do not communicate over a network (e.g., GitHub Copilot,
+ * which uses its own SDK transport) omit `endpoints`.
+ * @example Anthropic provider definition
+ * ```ts
+ * {
+ *   id: 'anthropic',
+ *   name: 'Anthropic',
+ *   description: 'Official Anthropic Claude API',
+ *   endpoints: { anthropic: 'https://api.anthropic.com' },
+ *   defaultModel: 'claude-sonnet-4-5',
+ *   fastModel: 'claude-haiku-4-5',
+ *   credentialEnvVars: { apiKey: 'ANTHROPIC_API_KEY' },
+ * }
+ * ```
+ * `availableModels` is omitted — the registry service populates it from the
+ * YAML lab registry at boot time and defaults to `[]` when absent.
+ */
+declare const ProviderDefinitionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  endpoints: z.ZodOptional<z.ZodObject<{
+    anthropic: z.ZodOptional<z.ZodString>;
+    openai: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  defaultModel: z.ZodOptional<z.ZodString>;
+  fastModel: z.ZodOptional<z.ZodString>;
+  primaryTestModel: z.ZodOptional<z.ZodString>;
+  secondaryTestModel: z.ZodOptional<z.ZodString>;
+  availableModels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    friendlyName: z.ZodOptional<z.ZodString>;
+    family: z.ZodOptional<z.ZodString>;
+    contextWindowSize: z.ZodNumber;
+    labId: z.ZodString;
+    supportedReasoningLevels: z.ZodOptional<z.ZodObject<{
+      none: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+      low: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+      medium: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+      high: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+      'extra-high': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+      maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+      capabilities: z.ZodOptional<z.ZodObject<{
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolCalling: z.ZodOptional<z.ZodBoolean>;
+        parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+        structuredOutput: z.ZodOptional<z.ZodBoolean>;
+        pdfUpload: z.ZodOptional<z.ZodBoolean>;
+        speechToText: z.ZodOptional<z.ZodObject<{
+          modes: z.ZodArray<z.ZodEnum<{
+            batch: "batch";
+            streaming: "streaming";
+          }>>;
+          vocabularyBiasing: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        textToSpeech: z.ZodOptional<z.ZodObject<{
+          modes: z.ZodArray<z.ZodEnum<{
+            streaming: "streaming";
+            buffered: "buffered";
+          }>>;
+          voiceSelection: z.ZodOptional<z.ZodBoolean>;
+          voiceInstructions: z.ZodOptional<z.ZodBoolean>;
+          outputFormats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+      pricing: z.ZodOptional<z.ZodObject<{
+        token: z.ZodOptional<z.ZodObject<{
+          inputPerMillion: z.ZodNumber;
+          inputCachedPerMillion: z.ZodOptional<z.ZodNumber>;
+          cacheWritePerMillion: z.ZodOptional<z.ZodNumber>;
+          outputPerMillion: z.ZodNumber;
+        }, z.core.$strip>>;
+        request: z.ZodOptional<z.ZodObject<{
+          multiplier: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+      includedInSubscription: z.ZodOptional<z.ZodBoolean>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  defaultModelFilterMode: z.ZodOptional<z.ZodEnum<{
+    allowlist: "allowlist";
+    "show-all": "show-all";
+  }>>;
+  credentialEnvVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Inferred output type for a fully-parsed provider definition.
+ *
+ * Fields with `.default()` (e.g., `availableModels`) are always present here.
+ * Use this type for runtime consumers that read provider definition values.
+ */
+type ProviderDefinition = z.infer<typeof ProviderDefinitionSchema>;
+/**
+ * Input type for provider definition declarations.
+ *
+ * Fields with `.default()` (e.g., `availableModels`) are optional here —
+ * the registry service populates them from YAML at boot time.
+ * Use this type when declaring a static `providerDefinition` constant in a
+ * provider package so that `availableModels` may be omitted.
+ */
+type ProviderDefinitionInput = z.input<typeof ProviderDefinitionSchema>;
+//#endregion
+export { ProviderDefinition as a, ProtocolIdSchema as i, ProtocolEndpointsSchema as n, ProviderDefinitionInput as o, ProtocolId as r, ProviderDefinitionSchema as s, ProtocolEndpoints as t };

package/dist/drizzle-Eq8W1EbD.mjs

@@ -0,0 +1 @@
+import{and as e,eq as t,getTableColumns as n,inArray as r,sql as i}from"drizzle-orm";import{didAffectRows as a}from"@makaio/framework/storage/drizzle";function o(e,t){return{[e]:t}}function s(e,t,r){let i=n(e);if(!r)return i[t];let a=r(e);if(a.length===0)throw Error(`createDrizzleCrudHandlers: conflictTarget returned an empty array. Provide at least one column for the conflict target.`);return a}function c(e,r,i){let{table:a,idField:s,singularKey:c,mapper:l,getSubject:u}=i;return e.on(u,async e=>{let{id:i}=e.payload,u=n(a)[s],[d]=await r.select().from(a).where(t(u,i)).limit(1);e.setResult(o(c,d?l(d):null))})}function l(e,r,a){let{table:o,idField:s,singularKey:c,mapper:l,toDbValues:u,setSubject:d,resolvedConflictTarget:f,lifecycle:p}=a;return e.on(d,async a=>{let d=a.payload[c],m=d[s],h=Date.now(),g=n(o),_=u(d),v={..._,[s]:m,createdAt:h,updatedAt:h};if(!p){await r.insert(o).values(v).onConflictDoUpdate({target:f,set:{..._,[s]:m,updatedAt:h,createdAt:i`COALESCE(${g.createdAt}, excluded.created_at)`}}),a.setResult({id:m});return}let y=await r.insert(o).values(v).onConflictDoNothing({target:f}).returning();if(y.length>0){await e.emit(p.created,l(y[0])),a.setResult({id:m});return}let[b]=await r.update(o).set({..._,updatedAt:h}).where(t(g[s],m)).returning();b&&await e.emit(p.updated,l(b)),a.setResult({id:m})})}function u(e,r,i){let{table:o,idField:s,deleteSubject:c}=i;return e.on(c,async e=>{let{id:i}=e.payload,c=n(o)[s],l=await r.delete(o).where(t(c,i));e.setResult({deleted:a(l)})})}function d(e,r,i){let{table:a,idField:o,singularKey:s,getSubject:c,deleteSubject:l,lifecycle:u}=i;return e.on(l,async i=>{let{id:l}=i.payload,d=n(a)[o],[f]=await r.select({id:d}).from(a).where(t(d,l)).limit(1);await i.next(),f&&((await e.request(c,{id:l}))[s]||await e.emit(u.deleted,{id:l}))})}function f(e){if(e.conflictTarget&&e.lifecycle)throw Error(`createDrizzleCrudHandlers: conflictTarget is not yet compatible with lifecycle events. The lifecycle path uses a PK-based UPDATE fallback that cannot resolve rows by natural key.`);let{table:t,subjects:n,idField:r,singularKey:i,mapper:a,toDbValues:o,conflictTarget:f,lifecycle:p}=e,m=s(t,r,f);return(e,s)=>{let f=[];return f.push(c(e,s,{table:t,idField:r,singularKey:i,mapper:a,getSubject:n.get})),f.push(l(e,s,{table:t,idField:r,singularKey:i,mapper:a,toDbValues:o,setSubject:n.set,resolvedConflictTarget:m,lifecycle:p})),p&&f.push(d(e,s,{table:t,idField:r,singularKey:i,getSubject:n.get,deleteSubject:n.delete,lifecycle:p})),f.push(u(e,s,{table:t,idField:r,deleteSubject:n.delete})),()=>f.forEach(e=>e())}}function p(t){let{table:n,subject:r,pluralKey:i,mapper:a,buildPredicates:o}=t;return(t,s)=>{let c=(e,t)=>({[e]:t});return t.on(r,async t=>{let r=o(t.payload,n),l=r.length>0?e(...r):void 0,u=l?await s.select().from(n).where(l):await s.select().from(n);t.setResult(c(i,u.map(a)))})}}function m(e,n){return n?[r(e.scope,[`default`,n])]:[t(e.scope,`default`)]}export{p as n,f as r,m as t};