diff --git a/di/log/init.q b/di/log/init.q
new file mode 100644
index 00000000..0d9eaadc
--- /dev/null
+++ b/di/log/init.q
@@ -0,0 +1,4 @@
+// simple stdout logger - default log dependency for di.* modules
+\l ::log.q
+
+export:([trace;debug;info;warn;error;fatal;createLog])
diff --git a/di/log/log.md b/di/log/log.md
new file mode 100644
index 00000000..b4acc09e
--- /dev/null
+++ b/di/log/log.md
@@ -0,0 +1,169 @@
+# Log
+
+`log.q` is the default logging implementation for `di.*` modules. It writes formatted lines to stdout and satisfies the log dependency contract expected by modules such as `di.email`.
+
+## Usage
+
+```q
+logger:use`di.log
+logger.trace[`mymodule;"entering function"]
+logger.debug[`mymodule;"value is 42"]
+logger.info[`mymodule;"starting up"]
+logger.warn[`mymodule;"disk usage above 80%"]
+logger.error[`mymodule;"connection failed"]
+logger.fatal[`mymodule;"unrecoverable error, shutting down"]
+```
+
+Output format:
+
+```
+2026-04-09T12:00:00.000000000 [TRACE] [mymodule] entering function
+2026-04-09T12:00:00.001000000 [DEBUG] [mymodule] value is 42
+2026-04-09T12:00:00.002000000 [INFO] [mymodule] starting up
+2026-04-09T12:00:00.003000000 [WARN] [mymodule] disk usage above 80%
+2026-04-09T12:00:00.004000000 [ERROR] [mymodule] connection failed
+2026-04-09T12:00:00.005000000 [FATAL] [mymodule] unrecoverable error, shutting down
+```
+
+## Injecting into other modules
+
+All `di.*` modules that accept a log dependency expect a dictionary with keys `` `info`warn`error ``, each a function with signature `{[ctx;msg]}`.
+
+```q
+logger:use`di.log
+logdep:`info`warn`error!(logger.info;logger.warn;logger.error)
+
+email:use`di.email
+email.init[enlist[`log]!enlist logdep]
+```
+
+You can extend the injected dictionary with `trace`, `debug`, and `fatal` for modules that support them:
+
+```q
+logdep:`trace`debug`info`warn`error`fatal!(logger.trace;logger.debug;logger.info;logger.warn;logger.error;logger.fatal)
+```
+
+`di.log` has no dependencies of its own, so there's no `init` to call on it first — use
+`defaultdict` to skip building the dict by hand. It's the dependency already wrapped
+as `` `log!enlist logdict ``, ready to pass straight into any `di.*` module's `init`:
+
+```q
+mylog:use`di.log
+email:use`di.email
+email.init[mylog.defaultdict]
+```
+
+## createLog
+
+`createLog` is a factory that returns an independent logger instance with level filtering, multiple output sinks, and configurable format templates. Each call to `createLog` produces a separate instance with its own state.
+
+```q
+logger:use`di.log
+mylog:logger.createLog[]
+
+mylog.setlvl `warn                        / suppress trace, debug, info
+mylog.info "this is suppressed"           / returns () silently
+mylog.warn "this appears"
+
+mylog.setfmt `syslog                      / switch to syslog format
+mylog.addfmt[`compact;"$l $m"]           / add a custom format
+mylog.setfmt `compact
+
+mylog.add[2i;`error`fatal]               / add stderr sink for error and fatal
+mylog.remove[1i;`trace]                  / remove stdout from trace level
+```
+
+### Sinks
+
+A sink is a handle (integer file descriptor or function) passed to `add`. If a function is provided it is called with the formatted line string. Built-in handles follow standard q conventions: `1i` is stdout, `2i` is stderr.
+
+```q
+buf:();
+capture:{[msg] buf,:enlist msg};         / function sink - captures output
+mylog.add[capture;`info`warn`error]
+mylog.info "captured"
+buf                                      / ("2026-...captured\n")
+mylog.remove[capture;`info]
+```
+
+### Format templates
+
+Three built-in formats are available:
+
+| Name | Template | Example output |
+|---|---|---|
+| `basic` (default) | `$p $l PID[$i] HOST[$h] $m` | `2026-04-09T12:00:00.000000000 INFO PID[1234] HOST[myhost] message` |
+| `syslog` | `<$s> $m` | `<6> message` |
+| `raw` | `$m` | `message` |
+
+Template variables: `$p` timestamp, `$l` level, `$i` PID, `$h` hostname, `$m` message, `$s` syslog severity number.
+
+## API
+
+### `trace`
+Parameters: `[ctx; msg]`
+
+Write a trace-level message to stdout.
+
+- `ctx` — symbol context tag (e.g. `` `mymodule ``)
+- `msg` — string message
+
+### `debug`
+Parameters: `[ctx; msg]`
+
+Write a debug-level message to stdout.
+
+### `info`
+Parameters: `[ctx; msg]`
+
+Write an info-level message to stdout.
+
+### `warn`
+Parameters: `[ctx; msg]`
+
+Write a warning-level message to stdout.
+
+### `error`
+Parameters: `[ctx; msg]`
+
+Write an error-level message to stdout.
+
+### `fatal`
+Parameters: `[ctx; msg]`
+
+Write a fatal-level message to stdout.
+
+### `defaultdict`
+A dictionary, not a function.
+
+`` `log!enlist(`info`warn`error!(info;warn;error))`` — the log dependency dict pre-wrapped
+exactly as any `di.*` module's `init` expects `deps`, so it can be passed straight through
+without building it by hand.
+
+### `createLog`
+Parameters: none
+
+Returns an independent logger instance as a dictionary of functions. Each call returns a new instance with isolated state.
+
+Returned keys: `` `trace`debug`info`warn`error`fatal`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl ``
+
+| Function | Parameters | Description |
+|---|---|---|
+| `trace`..`fatal` | `[msg]` | Write a message at the given level (filtered by active level) |
+| `setlvl` | `[lvl]` | Set minimum level; one of `` `trace`debug`info`warn`error`fatal `` |
+| `getlvl` | `[_]` | Return current minimum level |
+| `setfmt` | `[name]` | Switch to a named format template |
+| `getfmt` | `[_]` | Return current format name |
+| `addfmt` | `[name;template]` | Register a new named format template |
+| `add` | `[handle;lvls]` | Add a sink for one or more levels; returns the handle |
+| `remove` | `[handle;lvl]` | Remove a sink from a level |
+
+## Log dependency contract
+
+The log dependency contract used across `di.*` modules requires a dictionary:
+
+```q
+`info`warn`error!({[ctx;msg] ...};{[ctx;msg] ...};{[ctx;msg] ...})
+```
+
+`di.log` satisfies this contract. You can also supply any custom implementation with the same signatures.
\ No newline at end of file
diff --git a/di/log/log.q b/di/log/log.q
new file mode 100644
index 00000000..3bb54f42
--- /dev/null
+++ b/di/log/log.q
@@ -0,0 +1,190 @@
+/ simple stdout logger for di.* modules
+/ provides info, warn, error, trace, debug, fatal with signature {[ctx;msg]}
+/ ctx is a symbol context tag, msg is a string
+/ also provides createLog, a factory for rich structured logger instances
+
+/ os-aware newline
+nl:$[.z.o in `w32`w64;"\r\n";"\n"];
+
+/ log levels in priority order
+lvls:`trace`debug`info`warn`error`fatal;
+
+/ syslog severity per level (rfc5424)
+syslogLvl:lvls!7 7 6 4 3 2i;
+
+/ built-in format templates for createLog instances
+fmts:`basic`syslog`raw!("$p $l PID[$i] HOST[$h] $m";"<$s> $m";"$m");
+
+/ format pattern handlers for createLog instances; each takes {[level;msg]}
+/ level is an uppercase string (e.g. "INFO"), msg is the formatted message string
+pattern:"plihms~"!(
+  {[x;y] string .z.p};
+  {[x;y] x};
+  {[x;y] string .z.i};
+  {[x;y] string .z.h};
+  {[x;y] y};
+  {[x;y] string .z.M.syslogLvl`$lower x};
+  {[x;y] "$"});
+
+/ split a format template on delimiter, returning (textparts; substitutionfunctions)
+/ escaped delimiter (e.g. $$) is replaced by $~ which resolves to literal $
+fmtprep:{[del;rep;fmt]
+  fmt:ssr[fmt;del,del;del,"~"];
+  parts:del vs fmt;
+  fns:rep@first each 1_parts;
+  (enlist[first parts],1_/:1_parts;fns)
+  };
+
+/ apply a prepared format returning the assembled line string
+/ level is an uppercase string, msg is the formatted message string
+fmtapply:{[prep;level;msg]
+  textparts:prep 0;
+  fns:prep 1;
+  vals:fns .\:(level;msg);
+  raze first[textparts],vals,'1_textparts
+  };
+
+/ apply printf-style variable substitution to a message
+/ msg is a plain string or (fmtstring;arg1;arg2;...)
+/ %s converts to string, %r uses .Q.s1, %% becomes a literal percent
+fmtmsg:{[msg]
+  $[10h=abs type msg;
+    msg;
+    [fmt:first msg;
+     args:1_msg;
+     fmt:ssr[fmt;"%%";"\000"];
+     parts:"%" vs fmt;
+     subs:"sr"!({$[10h=abs type x;x;-11h=type x;string x;'`type]};.Q.s1);
+     result:first[parts],raze {[subs;args;parts;i]
+       part:parts[1+i];
+       code:first part;
+       rest:1_part;
+       if[not code in key subs;'`$"unsupported format char: ",enlist code];
+       (subs[code] args[i]),rest
+     }[subs;args;parts;] each til count[parts]-1;
+     ssr[result;"\000";"%"]
+    ]
+  ]};
+
+/ format and write a log line to stdout using the dependency-contract format
+logline:{[level;ctx;msg]
+  -1 (string .z.p)," [",level,"] [",string[ctx],"] ",msg;
+  };
+
+
+/ instance counter and per-instance state; bare names fall back to .z.M when .z.m not yet set
+i:0;
+inst:()!();
+
+/ factory helper: returns a 1-arg {[msg]} log function for the given level and instance
+/ each entry in sink is a (handle;sender) pair; sender is called with the formatted text
+makelevel:{[id;gv;lvl]
+  {[id;gv;lvl;msg]
+    if[(lvls?lvl)<lvls?gv`lvl;:()];
+    txt:fmtapply[gv`prep;upper string lvl;fmtmsg msg],nl;
+    {[txt;pair]
+      @[last pair;txt;{x}]
+    }[txt;] each (gv`sink)[lvl];
+  }[id;gv;lvl;]
+  };
+
+/ update field k with value v in instance id's state
+updInst:{[id;k;v]
+  state:inst;
+  state[id;k]:v;
+  .z.m.inst:state;
+  };
+
+
+/ ============================================================
+/ public api
+/ ============================================================
+
+/ simple dependency-contract-compatible log functions; each has signature {[ctx;msg]}
+trace:{[ctx;msg] logline["TRACE";ctx;msg];};
+debug:{[ctx;msg] logline["DEBUG";ctx;msg];};
+info:{[ctx;msg] logline["INFO";ctx;msg];};
+warn:{[ctx;msg] logline["WARN";ctx;msg];};
+error:{[ctx;msg] logline["ERROR";ctx;msg];};
+fatal:{[ctx;msg] logline["FATAL";ctx;msg];};
+
+/ pre-wrapped log dependency dict ready to pass straight into any di.* module's init
+/ e.g. email.init[mylog.defaultdict]
+defaultdict:(enlist`log)!enlist(`info`warn`error!(info;warn;error));
+
+/ create a logger instance with level filtering, multiple formatters and sinks
+/ returns a dictionary of functions; each call returns an independent instance
+/ sink entries are (handle;sender) pairs; sender is called with the formatted text
+createLog:{[]
+  / increment instance counter and capture id
+  .z.m.i+:1;
+  id:i;
+  / initialise state for this instance; no separate handler dict needed
+  snk:lvls!(count lvls)#enlist();
+  prp:fmtprep["$";pattern;fmts`basic];
+  state:inst;
+  state[id]:`sink`lvl`fmtname`fmts`prep!(snk;`info;`basic;fmts;prp);
+  .z.m.inst:state;
+
+  / helpers that close over id to read and write this instance's state
+  gv:{.z.m.inst[x][y]}[id;];
+  wv:updInst[id;;];
+
+  / set active format by name; recomputes the prepared format template
+  setfmt:{[gv;wv;name]
+    f:gv`fmts;
+    if[not name in key f;'"invalid format: ",string name];
+    wv[`prep;fmtprep["$";pattern;f name]];
+    wv[`fmtname;name];
+  }[gv;wv;];
+
+  / get the current format name; 1-arg (dummy ignored) so gv executes in module context
+  getfmt:{[gv;x] gv`fmtname}[gv;];
+
+  / add a custom named format template string
+  addfmt:{[gv;wv;name;fmt]
+    wv[`fmts;@[gv`fmts;name;:;fmt]];
+  }[gv;wv;;];
+
+  / set minimum log level; messages below this level are suppressed
+  setlvl:{[gv;wv;newlvl]
+    if[not newlvl in lvls;'"invalid level: ",string newlvl];
+    wv[`lvl;newlvl];
+  }[gv;wv;];
+
+  / get the current minimum log level; 1-arg (dummy ignored) so gv executes in module context
+  getlvl:{[gv;x] gv`lvl}[gv;];
+
+  / add a sink (handle or (handle;fn) pair) for one or more log levels
+  / each sink entry is stored as (handle;sender) so mixed types never collide in a dict
+  add:{[id;gv;h;sinklvls]
+    handle:$[0h=type h;first h;h];
+    sender:$[0h=type h;last h;h];
+    {[id;handle;sender;lvl]
+      state:.z.m.inst;
+      sink:state[id;`sink];
+      sink[lvl],:enlist(handle;sender);
+      state[id;`sink]:sink;
+      .z.m.inst:state;
+    }[id;handle;sender;] each (),sinklvls;
+    handle
+  }[id;gv;;];
+
+  / remove a handle from a log level's sink list
+  remove:{[id;h;lvl]
+    state:.z.m.inst;
+    sink:state[id;`sink];
+    sink[lvl]:sink[lvl] where {[h;p] not h~first p}[h;] each sink[lvl];
+    state[id;`sink]:sink;
+    .z.m.inst:state;
+    h
+  }[id;;];
+
+  / initialise default sink: stdout for all levels
+  add[1i;lvls];
+
+  / return public interface as a dictionary of functions
+  (lvls,`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl)!
+    (makelevel[id;gv;] each lvls),
+    (add;remove;setfmt;getfmt;addfmt;setlvl;getlvl)
+  };
\ No newline at end of file
diff --git a/di/log/test.csv b/di/log/test.csv
new file mode 100644
index 00000000..423d86ae
--- /dev/null
+++ b/di/log/test.csv
@@ -0,0 +1,162 @@
+action,ms,bytes,lang,code,repeat,minver,comment
+before,0,0,q,lg:use`di.log,1,,load module into session
+
+/ Test 0: simple ctx-based functions exist and are callable
+true,0,0,q,100h=type lg.trace,1,,trace is a function
+true,0,0,q,100h=type lg.debug,1,,debug is a function
+true,0,0,q,100h=type lg.info,1,,info is a function
+true,0,0,q,100h=type lg.warn,1,,warn is a function
+true,0,0,q,100h=type lg.error,1,,error is a function
+true,0,0,q,100h=type lg.fatal,1,,fatal is a function
+
+/ Test 1: simple functions conform to {[ctx;msg]} contract signature
+true,0,0,q,2=count (value lg.info)1,1,,info takes 2 parameters
+true,0,0,q,2=count (value lg.warn)1,1,,warn takes 2 parameters
+true,0,0,q,2=count (value lg.error)1,1,,error takes 2 parameters
+true,0,0,q,2=count (value lg.trace)1,1,,trace takes 2 parameters
+true,0,0,q,2=count (value lg.debug)1,1,,debug takes 2 parameters
+true,0,0,q,2=count (value lg.fatal)1,1,,fatal takes 2 parameters
+
+/ Test 2: simple functions do not throw on valid inputs
+run,0,0,q,lg.info[`di.log;"test info message"],1,,info with symbol ctx and string msg
+run,0,0,q,lg.warn[`di.log;"test warn message"],1,,warn with symbol ctx and string msg
+run,0,0,q,lg.error[`di.log;"test error message"],1,,error with symbol ctx and string msg
+run,0,0,q,lg.trace[`di.log;"test trace message"],1,,trace with symbol ctx and string msg
+run,0,0,q,lg.debug[`di.log;"test debug message"],1,,debug with symbol ctx and string msg
+run,0,0,q,lg.fatal[`di.log;"test fatal message"],1,,fatal with symbol ctx and string msg
+
+/ Test 3: simple functions accept any symbol ctx
+run,0,0,q,lg.info[`mymodule;"processing data"],1,,info with custom module ctx
+run,0,0,q,lg.warn[`mymodule;"approaching limit"],1,,warn with custom module ctx
+run,0,0,q,lg.error[`mymodule;"operation failed"],1,,error with custom module ctx
+
+/ Test 4: createLog is exported and is a function
+true,0,0,q,100h=type lg.createLog,1,,createLog is a function
+
+/ Test 5: createLog returns a dictionary with all expected keys
+before,0,0,q,log1:lg.createLog[],1,,create first logger instance
+true,0,0,q,`trace`debug`info`warn`error`fatal`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl~key log1,1,,createLog returns dict with expected keys
+
+/ Test 6: all level functions in returned dict are callable (projections: 104h)
+true,0,0,q,104h=type log1`trace,1,,instance trace is a function
+true,0,0,q,104h=type log1`debug,1,,instance debug is a function
+true,0,0,q,104h=type log1`info,1,,instance info is a function
+true,0,0,q,104h=type log1`warn,1,,instance warn is a function
+true,0,0,q,104h=type log1`error,1,,instance error is a function
+true,0,0,q,104h=type log1`fatal,1,,instance fatal is a function
+
+/ Test 7: management functions are callable (all projections: 104h)
+true,0,0,q,104h=type log1`setlvl,1,,setlvl is a function
+true,0,0,q,104h=type log1`getlvl,1,,getlvl is a function
+true,0,0,q,104h=type log1`setfmt,1,,setfmt is a function
+true,0,0,q,104h=type log1`getfmt,1,,getfmt is a function
+true,0,0,q,104h=type log1`addfmt,1,,addfmt is a function
+true,0,0,q,104h=type log1`add,1,,add is a function
+true,0,0,q,104h=type log1`remove,1,,remove is a function
+
+/ Test 8: default level is info
+true,0,0,q,`info~log1.getlvl[0],1,,default log level is info
+
+/ Test 9: default format is basic
+true,0,0,q,`basic~log1.getfmt[0],1,,default format is basic
+
+/ Test 10: setlvl changes the active level
+run,0,0,q,log1.setlvl `warn,1,,set level to warn
+true,0,0,q,`warn~log1.getlvl[0],1,,getlvl returns warn after setlvl
+
+/ Test 11: setlvl rejects invalid levels
+true,0,0,q,@[log1.setlvl;`notexist;{1b}],1,,setlvl throws on unknown level
+
+/ Test 12: messages below filter level return () silently
+true,0,0,q,()~log1.info "this should be suppressed",1,,info below warn filter returns ()
+run,0,0,q,log1.setlvl `info,1,,restore level to info
+
+/ Test 13: level functions do not throw on valid messages
+run,0,0,q,log1.info "test message",1,,instance info accepts plain string
+run,0,0,q,log1.warn "test warning",1,,instance warn accepts plain string
+
+/ Test 14: setfmt changes the active format
+run,0,0,q,log1.setfmt `syslog,1,,set format to syslog
+true,0,0,q,`syslog~log1.getfmt[0],1,,getfmt returns syslog after setfmt
+run,0,0,q,log1.setfmt `raw,1,,set format to raw
+true,0,0,q,`raw~log1.getfmt[0],1,,getfmt returns raw after setfmt
+run,0,0,q,log1.setfmt `basic,1,,restore format to basic
+
+/ Test 15: setfmt rejects unknown format names
+true,0,0,q,@[log1.setfmt;`notexist;{1b}],1,,setfmt throws on unknown format
+
+/ Test 16: addfmt adds a new named format
+run,0,0,q,log1.addfmt[`compact;"$l $m"],1,,add compact format
+run,0,0,q,log1.setfmt `compact,1,,switch to custom compact format
+true,0,0,q,`compact~log1.getfmt[0],1,,getfmt returns custom format name
+run,0,0,q,log1.setfmt `basic,1,,restore to basic
+
+/ Test 17: each createLog call returns an independent instance
+before,0,0,q,log2:lg.createLog[],1,,create second logger instance
+run,0,0,q,log2.setlvl `error,1,,set log2 level to error
+true,0,0,q,`info~log1.getlvl[0],1,,log1 level unaffected by log2 setlvl
+true,0,0,q,`error~log2.getlvl[0],1,,log2 level is error independently
+
+/ Test 18: add with a function sink returns the function handle
+before,0,0,q,nosink:{[msg] 1b},1,,define a no-op function sink
+true,0,0,q,nosink~log1.add[nosink;`info],1,,add returns the registered function handle
+run,0,0,q,log1.remove[nosink;`info],1,,remove function sink from info level
+
+/ Test 19: fmtmsg plain string passes through (internal helper, tested indirectly)
+run,0,0,q,log1.info "plain string message",1,,instance info with plain string
+run,0,0,q,log1.info ("message with %s";`symbol),1,,instance info with %s substitution
+run,0,0,q,log1.info ("message with %r";"raw repr"),1,,instance info with %r substitution
+run,0,0,q,log1.info "literal 100%% complete",1,,instance info with %% escape
+
+/ Test 20: trace, debug and fatal accept any symbol ctx
+run,0,0,q,lg.trace[`mymodule;"trace custom ctx"],1,,trace with custom module ctx
+run,0,0,q,lg.debug[`mymodule;"debug custom ctx"],1,,debug with custom module ctx
+run,0,0,q,lg.fatal[`mymodule;"fatal custom ctx"],1,,fatal with custom module ctx
+
+/ Test 21: instance trace, debug and fatal do not throw
+run,0,0,q,log1.setlvl `trace,1,,lower level to trace so trace and debug are not suppressed
+run,0,0,q,log1.trace "test trace",1,,instance trace accepts plain string
+run,0,0,q,log1.debug "test debug",1,,instance debug accepts plain string
+run,0,0,q,log1.fatal "test fatal",1,,instance fatal accepts plain string
+run,0,0,q,log1.setlvl `info,1,,restore level to info
+
+/ Test 22: function sink captures formatted output
+before,0,0,q,log3:lg.createLog[],1,,create logger for sink capture test
+before,0,0,q,captured:(),1,,initialise capture buffer
+before,0,0,q,"capfn:{captured::captured,enlist x}",1,,define capture function that appends to global
+run,0,0,q,log3.add[capfn;`info],1,,add function sink to info level
+run,0,0,q,log3.info "sink test message",1,,send message through function sink
+true,0,0,q,0<count captured,1,,function sink received output
+true,0,0,q,"any {0<count x ss ""sink test message""} each captured",1,,captured output contains the message text
+
+/ Test 23: setlvl `fatal suppresses all levels below fatal
+before,0,0,q,log4:lg.createLog[],1,,create logger for fatal-level filter test
+before,0,0,q,fcaptured:(),1,,initialise fatal capture buffer
+before,0,0,q,"ffn:{fcaptured::fcaptured,enlist x}",1,,define fatal capture function
+run,0,0,q,"log4.add[ffn;`trace`debug`info`warn`error`fatal]",1,,add sink to all levels
+run,0,0,q,log4.setlvl `fatal,1,,set level to fatal
+true,0,0,q,"()~log4.info ""suppressed""",1,,info suppressed at fatal level
+true,0,0,q,"()~log4.warn ""suppressed""",1,,warn suppressed at fatal level
+true,0,0,q,"()~log4.error ""suppressed""",1,,error suppressed at fatal level
+true,0,0,q,0=count fcaptured,1,,no messages captured below fatal level
+run,0,0,q,"log4.fatal ""fatal passes through""",1,,fatal level passes through
+true,0,0,q,0<count fcaptured,1,,fatal level message was captured
+
+/ Test 24: defaultdict is a dictionary pre-wrapped under a single `log` key
+true,0,0,q,99h=type lg.defaultdict,1,,defaultdict is a dictionary
+true,0,0,q,enlist[`log]~key lg.defaultdict,1,,defaultdict has a single `log key
+
+/ Test 25: defaultdict`log holds the info/warn/error contract dict
+true,0,0,q,`info`warn`error~key lg.defaultdict`log,1,,defaultdict log dict has info/warn/error keys
+true,0,0,q,lg.info~(lg.defaultdict`log)`info,1,,defaultdict info matches lg.info
+true,0,0,q,lg.warn~(lg.defaultdict`log)`warn,1,,defaultdict warn matches lg.warn
+true,0,0,q,lg.error~(lg.defaultdict`log)`error,1,,defaultdict error matches lg.error
+
+/ Test 26: functions in defaultdict conform to {[ctx;msg]} contract signature
+true,0,0,q,2=count (value (lg.defaultdict`log)`info)1,1,,defaultdict info takes 2 parameters
+true,0,0,q,2=count (value (lg.defaultdict`log)`warn)1,1,,defaultdict warn takes 2 parameters
+true,0,0,q,2=count (value (lg.defaultdict`log)`error)1,1,,defaultdict error takes 2 parameters
+
+/ Test 27: defaultdict can be passed straight into a consumer's init unmodified
+before,0,0,q,"mockinit:{[deps] not ()~deps[`log]`info}",1,,define mock consumer init that checks log dep wiring
+true,0,0,q,mockinit[lg.defaultdict],1,,defaultdict satisfies a typical consumer init signature
\ No newline at end of file