@flowrunner/cli 0.1.17 → 0.1.18-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/ai-docs/instructions/service-code-format/02-zod-types.md +139 -33
  2. package/ai-docs/instructions/service-code-format/03-parameters.md +3 -1
  3. package/ai-docs/instructions/service-code-format/05-dictionaries.md +8 -2
  4. package/ai-docs/instructions/service-code-format/07-actions.md +1 -1
  5. package/ai-docs/instructions/service-code-format/11-output-model.md +3 -0
  6. package/ai-docs/instructions/service-code-format/14-reference-service.md +1 -1
  7. package/ai-docs/instructions/service-code-format/16-gotchas.md +80 -0
  8. package/ai-docs/instructions/service-code-format/18-test-recipes.md +2 -1
  9. package/ai-docs/instructions/service-code-format/README.md +1 -1
  10. package/dist/cli.js +523 -82
  11. package/dist/cli.js.map +4 -4
  12. package/dist/index.js +522 -81
  13. package/dist/index.js.map +4 -4
  14. package/dist/types/flow-extension-runner/src/v2/context/execution-context.d.ts +8 -0
  15. package/dist/types/flow-extension-runner/src/v2/dictionaries/payload-schema.d.ts +1 -1
  16. package/dist/types/flow-extension-runner/src/v2/params/index.d.ts +2 -0
  17. package/dist/types/flow-extension-runner/src/v2/params/json/types.d.ts +2 -0
  18. package/dist/types/flow-extension-runner/src/v2/params/schema/date-format.d.ts +80 -0
  19. package/dist/types/flow-extension-runner/src/v2/params/schema/defaults.d.ts +4 -10
  20. package/dist/types/flow-extension-runner/src/v2/params/schema/field-plan.d.ts +7 -0
  21. package/dist/types/flow-extension-runner/src/v2/params/schema/notices.d.ts +15 -0
  22. package/dist/types/flow-extension-runner/src/v2/params/widget-types.d.ts +1 -1
  23. package/dist/types/flow-extension-runner/src/v2/params/zod.d.ts +30 -19
  24. package/dist/types/flow-extension-runner/src/v2/types.d.ts +1 -1
  25. package/package.json +1 -1
  26. package/runtime/index.js +529 -82
  27. package/runtime/index.js.map +4 -4
  28. package/runtime/types/flow-extension-runner/src/v2/context/execution-context.d.ts +8 -0
  29. package/runtime/types/flow-extension-runner/src/v2/dictionaries/payload-schema.d.ts +1 -1
  30. package/runtime/types/flow-extension-runner/src/v2/params/index.d.ts +2 -0
  31. package/runtime/types/flow-extension-runner/src/v2/params/json/types.d.ts +2 -0
  32. package/runtime/types/flow-extension-runner/src/v2/params/schema/date-format.d.ts +80 -0
  33. package/runtime/types/flow-extension-runner/src/v2/params/schema/defaults.d.ts +4 -10
  34. package/runtime/types/flow-extension-runner/src/v2/params/schema/field-plan.d.ts +7 -0
  35. package/runtime/types/flow-extension-runner/src/v2/params/schema/notices.d.ts +15 -0
  36. package/runtime/types/flow-extension-runner/src/v2/params/widget-types.d.ts +1 -1
  37. package/runtime/types/flow-extension-runner/src/v2/params/zod.d.ts +30 -19
  38. package/runtime/types/flow-extension-runner/src/v2/types.d.ts +1 -1
package/runtime/index.js CHANGED
@@ -11936,39 +11936,6 @@ function assertObjectSchema(scheme, source) {
11936
11936
  );
11937
11937
  }
11938
11938
 
11939
- // ../../flow-extension-runner/src/v2/params/schema/dictionary-binding.ts
11940
- var DictionaryScope = class _DictionaryScope {
11941
- constructor(top, visible) {
11942
- this.top = top;
11943
- this.visible = visible;
11944
- }
11945
- static {
11946
- this.ROOT = new _DictionaryScope(null, /* @__PURE__ */ new Set());
11947
- }
11948
- enter(names) {
11949
- if (!this.top) {
11950
- const top = new Set(names);
11951
- return new _DictionaryScope(top, top);
11952
- }
11953
- return new _DictionaryScope(this.top, /* @__PURE__ */ new Set([...this.top, ...names]));
11954
- }
11955
- };
11956
- function resolveDependsOn(binding, scope2) {
11957
- const aliases = binding.criteriaAliases ?? {};
11958
- let clash;
11959
- const dependsOn = binding.dependsOn.map((key) => {
11960
- const visible = [key, ...aliases[key] ?? []].filter((name) => scope2.visible.has(name));
11961
- if (visible.length > 1 && !clash) {
11962
- clash = { key, names: visible };
11963
- }
11964
- return visible[0] ?? key;
11965
- });
11966
- return clash ? { dependsOn, clash } : { dependsOn };
11967
- }
11968
- function publishedBinding(binding, scope2) {
11969
- return { id: binding.id, dependsOn: resolveDependsOn(binding, scope2).dependsOn };
11970
- }
11971
-
11972
11939
  // ../../flow-extension-runner/src/v2/params/widget-types.ts
11973
11940
  var FlowExtensionParamGroupTypes = {
11974
11941
  FILE_UPLOAD_OPTIONS: "FILE_UPLOAD_OPTIONS",
@@ -11987,7 +11954,9 @@ var FlowExtensionParamWidgetTypes = {
11987
11954
  ...FlowExtensionParamGroupTypes,
11988
11955
  // legacy — no zod declaration produces these. They reach the console only from a legacy JSDoc-format
11989
11956
  // service, which writes `uiComponent` by hand. Kept because the console still renders them for an
11990
- // already-installed extension.
11957
+ // already-installed extension. `DATE_TIME_PICKER` / `TIME_PICKER` are also published, with
11958
+ // `valueKind: 'string'` and `format`, by `z.iso.datetime({ local: true })` / `z.iso.time()` (FR-3920) —
11959
+ // without `valueKind` they are the legacy tokens, storing epoch millis.
11991
11960
  NUMERIC: "NUMERIC",
11992
11961
  CHECKBOX: "CHECKBOX",
11993
11962
  DATE_TIME_PICKER: "DATE_TIME_PICKER",
@@ -12082,15 +12051,12 @@ function literalType(core) {
12082
12051
  }
12083
12052
  function deriveWidget(ins) {
12084
12053
  const { coreType, core, meta } = ins;
12085
- if (meta.frJson) {
12086
- return { paramType: "STRING", uiComponent: { type: FlowExtensionParamWidgetTypes.MULTI_LINE_TEXT } };
12087
- }
12088
12054
  switch (coreType) {
12089
12055
  case "string":
12090
12056
  if (meta.frWidget === FlowExtensionParamWidgetTypes.MULTI_LINE_TEXT) {
12091
12057
  return { paramType: "STRING", uiComponent: { type: FlowExtensionParamWidgetTypes.MULTI_LINE_TEXT } };
12092
12058
  }
12093
- return { paramType: "STRING" };
12059
+ return dateStringWidget(ins) ?? { paramType: "STRING" };
12094
12060
  case "number":
12095
12061
  case "bigint":
12096
12062
  return { paramType: "NUMBER", uiComponent: { type: FlowExtensionParamWidgetTypes.NUMERIC_STEPPER } };
@@ -12133,11 +12099,380 @@ function deriveWidget(ins) {
12133
12099
  return { paramType: "STRING" };
12134
12100
  }
12135
12101
  }
12102
+ var DATE_STRING_WIDGETS = {
12103
+ date: FlowExtensionParamWidgetTypes.DATE_PICKER,
12104
+ datetime: FlowExtensionParamWidgetTypes.DATE_TIME_PICKER,
12105
+ time: FlowExtensionParamWidgetTypes.TIME_PICKER
12106
+ };
12107
+ function dateStringWidget(ins) {
12108
+ const kind = dateStringKind(ins);
12109
+ return kind ? { paramType: "STRING", uiComponent: { type: DATE_STRING_WIDGETS[kind], valueKind: "string", format: patternOf(ins, kind) } } : void 0;
12110
+ }
12136
12111
  function shapeEntries(schema) {
12137
12112
  const shape = schema?.shape;
12138
12113
  return shape && typeof shape === "object" ? Object.entries(shape) : [];
12139
12114
  }
12140
12115
 
12116
+ // ../../flow-extension-runner/src/v2/params/schema/date-format.ts
12117
+ var ISO_PATTERNS = {
12118
+ date: "yyyy-MM-dd",
12119
+ datetime: "yyyy-MM-dd'T'HH:mm",
12120
+ time: "HH:mm"
12121
+ };
12122
+ var DATE_STRINGS_ACCEPT_TIMESTAMPS = true;
12123
+ function dateStringKind(ins) {
12124
+ if (ins.coreType !== "string") {
12125
+ return void 0;
12126
+ }
12127
+ const def = ins.core?._zod?.def;
12128
+ if (def?.format === "date" || def?.format === "time") {
12129
+ return def.format;
12130
+ }
12131
+ return def?.format === "datetime" && def.local ? "datetime" : void 0;
12132
+ }
12133
+ var patternOf = (ins, kind) => ins.meta.frDateFormat ?? ISO_PATTERNS[kind];
12134
+ var TOKENS = ["yyyy", "yy", "MM", "M", "dd", "d", "HH", "H", "hh", "h", "mm", "ss", "a"];
12135
+ var SPEC = {
12136
+ yyyy: { part: "year", width: 4 },
12137
+ yy: { part: "year", width: 2 },
12138
+ MM: { part: "month", width: 2 },
12139
+ M: { part: "month" },
12140
+ dd: { part: "day", width: 2 },
12141
+ d: { part: "day" },
12142
+ HH: { part: "hour", width: 2 },
12143
+ H: { part: "hour" },
12144
+ hh: { part: "hour", width: 2 },
12145
+ h: { part: "hour" },
12146
+ mm: { part: "minute", width: 2 },
12147
+ ss: { part: "second", width: 2 },
12148
+ a: { part: "meridiem" }
12149
+ };
12150
+ var DATE_PARTS = /* @__PURE__ */ new Set(["year", "month", "day"]);
12151
+ var TIME_PARTS = /* @__PURE__ */ new Set(["hour", "minute", "second", "meridiem"]);
12152
+ var DateFormatError = class extends Error {
12153
+ };
12154
+ var LOOK_ALIKES = {
12155
+ YYYY: "yyyy",
12156
+ YY: "yy",
12157
+ DD: "dd",
12158
+ D: "d",
12159
+ S: "ss",
12160
+ A: "a"
12161
+ };
12162
+ function tokenize(pattern, kind) {
12163
+ const tokens = [];
12164
+ let index = 0;
12165
+ while (index < pattern.length) {
12166
+ const char = pattern[index];
12167
+ if (char === "'") {
12168
+ const end = pattern.indexOf("'", index + 1);
12169
+ if (end < 0) {
12170
+ throw new DateFormatError("has an unclosed quote \u2014 literal text is written between two single quotes");
12171
+ }
12172
+ tokens.push({ literal: end === index + 1 ? "'" : pattern.slice(index + 1, end) });
12173
+ index = end + 1;
12174
+ continue;
12175
+ }
12176
+ if (!/[A-Za-z]/.test(char)) {
12177
+ tokens.push({ literal: char });
12178
+ index++;
12179
+ continue;
12180
+ }
12181
+ const run = /^([A-Za-z])\1*/.exec(pattern.slice(index))?.[0];
12182
+ const known = TOKENS.find((token) => run.startsWith(token) && token.length === run.length);
12183
+ if (!known) {
12184
+ const hint2 = LOOK_ALIKES[run] ? ` (did you mean \`${suggest(pattern, kind)}\`?)` : "";
12185
+ throw new DateFormatError(
12186
+ `uses \`${run}\`, which is not a supported token${hint2}. Supported: yyyy yy MM M dd d HH H hh h mm ss a, and literal text in single quotes`
12187
+ );
12188
+ }
12189
+ tokens.push({ token: known });
12190
+ index += run.length;
12191
+ }
12192
+ return tokens;
12193
+ }
12194
+ function suggest(pattern, kind) {
12195
+ let fixed = pattern;
12196
+ for (const [wrong, right] of Object.entries(LOOK_ALIKES)) {
12197
+ fixed = fixed.replace(new RegExp(`(?<![A-Za-z])${wrong}(?![A-Za-z])`, "g"), right);
12198
+ }
12199
+ if (kind === "date") {
12200
+ fixed = fixed.replace(/mm/g, "MM");
12201
+ }
12202
+ return fixed;
12203
+ }
12204
+ var parsedPatterns = /* @__PURE__ */ new Map();
12205
+ function compilePattern(pattern, kind) {
12206
+ const key = `${kind}|${pattern}`;
12207
+ const cached = parsedPatterns.get(key);
12208
+ if (cached) {
12209
+ return cached;
12210
+ }
12211
+ if (typeof pattern !== "string" || !pattern.trim()) {
12212
+ throw new DateFormatError("needs a pattern, e.g. `dd/MM/yyyy`");
12213
+ }
12214
+ const tokens = tokenize(pattern, kind);
12215
+ const names = tokens.flatMap((token) => "token" in token ? [token.token] : []);
12216
+ const parts = names.map((name) => SPEC[name].part);
12217
+ const has = (part) => parts.includes(part);
12218
+ const repeated = parts.find((part, index) => parts.indexOf(part) !== index);
12219
+ if (repeated) {
12220
+ throw new DateFormatError(`names the ${repeated === "meridiem" ? "AM/PM" : repeated} twice`);
12221
+ }
12222
+ if (kind === "date" && names.includes("mm") && !has("hour")) {
12223
+ throw new DateFormatError(`uses \`mm\`, which is minutes \u2014 did you mean \`${suggest(pattern, kind)}\`?`);
12224
+ }
12225
+ if (kind === "date" && parts.some((part) => TIME_PARTS.has(part))) {
12226
+ throw new DateFormatError("has a time of day, which a date has not \u2014 declare `z.iso.datetime({ local: true })`");
12227
+ }
12228
+ if (kind === "time" && parts.some((part) => DATE_PARTS.has(part))) {
12229
+ throw new DateFormatError("has a date, which a time has not \u2014 declare `z.iso.datetime({ local: true })`");
12230
+ }
12231
+ const missing = [
12232
+ ...kind !== "time" ? [["year", "yyyy"], ["month", "MM"], ["day", "dd"]] : [],
12233
+ ...kind !== "date" ? [["hour", "HH"], ["minute", "mm"]] : []
12234
+ ].filter(([part]) => !has(part)).map(([, token]) => `\`${token}\``);
12235
+ if (missing.length) {
12236
+ throw new DateFormatError(`is missing ${missing.join(", ")} \u2014 every part of a ${describeKind(kind)} must be in it`);
12237
+ }
12238
+ if ((names.includes("hh") || names.includes("h")) && !names.includes("a")) {
12239
+ throw new DateFormatError(
12240
+ "uses a 12-hour clock (`hh` / `h`) without `a` \u2014 without AM/PM the value cannot be read back. Add `a`, or use `HH` for a 24-hour clock"
12241
+ );
12242
+ }
12243
+ parsedPatterns.set(key, tokens);
12244
+ return tokens;
12245
+ }
12246
+ var describeKind = (kind) => kind === "date" ? "date" : kind === "time" ? "time" : "date and time";
12247
+ var pad = (value, width) => String(value).padStart(width, "0");
12248
+ function formatParts(parts, pattern, kind) {
12249
+ return compilePattern(pattern, kind).map((token) => {
12250
+ if ("literal" in token) {
12251
+ return token.literal;
12252
+ }
12253
+ const hour = parts.hour ?? 0;
12254
+ switch (token.token) {
12255
+ case "yyyy":
12256
+ return pad(parts.year ?? 0, 4);
12257
+ case "yy":
12258
+ return pad((parts.year ?? 0) % 100, 2);
12259
+ case "MM":
12260
+ return pad(parts.month ?? 0, 2);
12261
+ case "M":
12262
+ return String(parts.month ?? 0);
12263
+ case "dd":
12264
+ return pad(parts.day ?? 0, 2);
12265
+ case "d":
12266
+ return String(parts.day ?? 0);
12267
+ case "HH":
12268
+ return pad(hour, 2);
12269
+ case "H":
12270
+ return String(hour);
12271
+ case "hh":
12272
+ return pad(hour % 12 || 12, 2);
12273
+ case "h":
12274
+ return String(hour % 12 || 12);
12275
+ case "mm":
12276
+ return pad(parts.minute ?? 0, 2);
12277
+ case "ss":
12278
+ return pad(parts.second ?? 0, 2);
12279
+ case "a":
12280
+ return hour < 12 ? "AM" : "PM";
12281
+ }
12282
+ }).join("");
12283
+ }
12284
+ var escapeRegex = (text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
12285
+ function parseInPattern(text2, pattern, kind) {
12286
+ const tokens = compilePattern(pattern, kind);
12287
+ const order = [];
12288
+ const source = tokens.map((token) => {
12289
+ if ("literal" in token) {
12290
+ return escapeRegex(token.literal);
12291
+ }
12292
+ order.push(token.token);
12293
+ if (token.token === "a") {
12294
+ return "(AM|PM)";
12295
+ }
12296
+ const { width } = SPEC[token.token];
12297
+ return width ? `(\\d{${width}})` : "(\\d{1,2})";
12298
+ }).join("");
12299
+ const match = new RegExp(`^${source}$`).exec(text2);
12300
+ if (!match) {
12301
+ return void 0;
12302
+ }
12303
+ const parts = {};
12304
+ let meridiem;
12305
+ order.forEach((name, index) => {
12306
+ const raw = match[index + 1];
12307
+ if (name === "a") {
12308
+ meridiem = raw;
12309
+ return;
12310
+ }
12311
+ const value = Number(raw);
12312
+ switch (name) {
12313
+ // date-fns' two-digit year rule against its reference year 2000: 00–49 → 20xx, 50–99 → 19xx.
12314
+ case "yy":
12315
+ parts.year = value < 50 ? 2e3 + value : 1900 + value;
12316
+ break;
12317
+ case "hh":
12318
+ case "h":
12319
+ parts.hour = value;
12320
+ break;
12321
+ default:
12322
+ parts[SPEC[name].part] = value;
12323
+ }
12324
+ });
12325
+ if (meridiem) {
12326
+ if (parts.hour === void 0 || parts.hour < 1 || parts.hour > 12) {
12327
+ return void 0;
12328
+ }
12329
+ parts.hour = parts.hour % 12 + (meridiem === "PM" ? 12 : 0);
12330
+ }
12331
+ const complete = completeParts(parts, kind);
12332
+ return complete && formatParts(complete, pattern, kind) === text2 ? complete : void 0;
12333
+ }
12334
+ function completeParts(parts, kind) {
12335
+ const { year, month, day, hour, minute, second } = parts;
12336
+ if (kind !== "time" && !isRealDate(year, month, day)) {
12337
+ return void 0;
12338
+ }
12339
+ if (kind !== "date" && !isRealTime(hour, minute, second)) {
12340
+ return void 0;
12341
+ }
12342
+ return kind === "date" ? { year, month, day } : kind === "time" ? { hour, minute, ...second !== void 0 ? { second } : {} } : { year, month, day, hour, minute, ...second !== void 0 ? { second } : {} };
12343
+ }
12344
+ function isRealDate(year, month, day) {
12345
+ if (year === void 0 || month === void 0 || day === void 0 || month < 1 || month > 12 || day < 1) {
12346
+ return false;
12347
+ }
12348
+ const leap = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
12349
+ const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
12350
+ return day <= days;
12351
+ }
12352
+ var isRealTime = (hour, minute, second) => hour !== void 0 && minute !== void 0 && hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && (second === void 0 || second >= 0 && second <= 59);
12353
+ var ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
12354
+ var ISO_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)?$/i;
12355
+ var ISO_TIME = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)?$/i;
12356
+ function parseIso(text2, kind) {
12357
+ const dateTime = ISO_DATE_TIME.exec(text2);
12358
+ if (dateTime) {
12359
+ const [, year, month, day, hour, minute, second] = dateTime.map(Number);
12360
+ return completeParts({ year, month, day, hour, minute, ...dateTime[6] ? { second } : {} }, kind);
12361
+ }
12362
+ const date = ISO_DATE.exec(text2);
12363
+ if (date) {
12364
+ return kind === "date" ? completeParts({ year: +date[1], month: +date[2], day: +date[3] }, kind) : void 0;
12365
+ }
12366
+ const time = ISO_TIME.exec(text2);
12367
+ if (time && kind === "time") {
12368
+ return completeParts({ hour: +time[1], minute: +time[2], ...time[3] ? { second: +time[3] } : {} }, kind);
12369
+ }
12370
+ return void 0;
12371
+ }
12372
+ function toCanonical(parts, kind) {
12373
+ const seconds = parts.second !== void 0 ? `:${pad(parts.second, 2)}` : "";
12374
+ const date = `${pad(parts.year ?? 0, 4)}-${pad(parts.month ?? 0, 2)}-${pad(parts.day ?? 0, 2)}`;
12375
+ const time = `${pad(parts.hour ?? 0, 2)}:${pad(parts.minute ?? 0, 2)}${seconds}`;
12376
+ return kind === "date" ? date : kind === "time" ? time : `${date}T${time}`;
12377
+ }
12378
+ function canonicalToPattern(canonical, ins, kind) {
12379
+ const pattern = ins.meta.frDateFormat;
12380
+ if (!pattern) {
12381
+ return canonical;
12382
+ }
12383
+ const parts = parseIso(canonical, kind);
12384
+ return parts ? formatParts(parts, pattern, kind) : canonical;
12385
+ }
12386
+ var isTimestamp = (value) => typeof value === "number" && Number.isFinite(value) || typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value.trim());
12387
+ function timestampParts(value, kind) {
12388
+ const date = new Date(Number(value));
12389
+ if (Number.isNaN(date.getTime())) {
12390
+ return void 0;
12391
+ }
12392
+ const second = date.getSeconds();
12393
+ return completeParts({
12394
+ year: date.getFullYear(),
12395
+ month: date.getMonth() + 1,
12396
+ day: date.getDate(),
12397
+ hour: date.getHours(),
12398
+ minute: date.getMinutes(),
12399
+ ...second ? { second } : {}
12400
+ }, kind);
12401
+ }
12402
+ function toDateString(value, ins, kind) {
12403
+ if (typeof value === "string") {
12404
+ const text2 = value.trim();
12405
+ const pattern = ins.meta.frDateFormat;
12406
+ const parts = (pattern ? parseInPattern(text2, pattern, kind) : void 0) ?? parseIso(text2, kind);
12407
+ if (parts) {
12408
+ return { canonical: toCanonical(parts, kind) };
12409
+ }
12410
+ }
12411
+ if (DATE_STRINGS_ACCEPT_TIMESTAMPS && isTimestamp(value)) {
12412
+ const parts = timestampParts(value, kind);
12413
+ return parts ? { canonical: toCanonical(parts, kind), fromTimestamp: true } : {};
12414
+ }
12415
+ return {};
12416
+ }
12417
+ var EXAMPLE = { year: 2024, month: 1, day: 31, hour: 13, minute: 45, second: 30 };
12418
+ function expectedDateString(ins, kind) {
12419
+ const pattern = patternOf(ins, kind);
12420
+ const shown = ins.meta.frDateFormat ? pattern : pattern.replace(/'T'/, "T");
12421
+ const example = formatParts(EXAMPLE, pattern, kind);
12422
+ return `${kind === "date" ? "a date" : kind === "time" ? "a time" : "a date and time"} in ${shown}, e.g. ${example}`;
12423
+ }
12424
+ function hasDateFormat(schema, seen = /* @__PURE__ */ new Set()) {
12425
+ if (!schema || seen.has(schema)) {
12426
+ return false;
12427
+ }
12428
+ seen.add(schema);
12429
+ const ins = inspect(schema);
12430
+ if (ins.meta.frDateFormat && dateStringKind(ins)) {
12431
+ return true;
12432
+ }
12433
+ const def = ins.core?._zod?.def ?? {};
12434
+ const children = [
12435
+ ...shapeEntries(ins.core).map(([, child]) => child),
12436
+ ...def.element ? [def.element] : [],
12437
+ ...def.valueType ? [def.valueType] : [],
12438
+ ...ins.branches ?? []
12439
+ ];
12440
+ return children.some((child) => hasDateFormat(child, seen));
12441
+ }
12442
+
12443
+ // ../../flow-extension-runner/src/v2/params/schema/dictionary-binding.ts
12444
+ var DictionaryScope = class _DictionaryScope {
12445
+ constructor(top, visible) {
12446
+ this.top = top;
12447
+ this.visible = visible;
12448
+ }
12449
+ static {
12450
+ this.ROOT = new _DictionaryScope(null, /* @__PURE__ */ new Set());
12451
+ }
12452
+ enter(names) {
12453
+ if (!this.top) {
12454
+ const top = new Set(names);
12455
+ return new _DictionaryScope(top, top);
12456
+ }
12457
+ return new _DictionaryScope(this.top, /* @__PURE__ */ new Set([...this.top, ...names]));
12458
+ }
12459
+ };
12460
+ function resolveDependsOn(binding, scope2) {
12461
+ const aliases = binding.criteriaAliases ?? {};
12462
+ let clash;
12463
+ const dependsOn = binding.dependsOn.map((key) => {
12464
+ const visible = [key, ...aliases[key] ?? []].filter((name) => scope2.visible.has(name));
12465
+ if (visible.length > 1 && !clash) {
12466
+ clash = { key, names: visible };
12467
+ }
12468
+ return visible[0] ?? key;
12469
+ });
12470
+ return clash ? { dependsOn, clash } : { dependsOn };
12471
+ }
12472
+ function publishedBinding(binding, scope2) {
12473
+ return { id: binding.id, dependsOn: resolveDependsOn(binding, scope2).dependsOn };
12474
+ }
12475
+
12141
12476
  // ../../flow-extension-runner/src/v2/params/schema/assert-supported-schema.ts
12142
12477
  var GUARDED_KINDS = /* @__PURE__ */ new Set(["action", "dictionary", "polling trigger", "realtime trigger", "extension"]);
12143
12478
  var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
@@ -12267,6 +12602,48 @@ function assertDictionaryBinding(schema, source, path2, scope2) {
12267
12602
  );
12268
12603
  }
12269
12604
  }
12605
+ function assertDateString(schema, source, path2) {
12606
+ const ins = inspect(schema);
12607
+ const pattern = ins.meta.frDateFormat;
12608
+ const kind = dateStringKind(ins);
12609
+ if (pattern !== void 0 && !kind) {
12610
+ const format = ins.core?._zod?.def?.format;
12611
+ const zoned = ins.coreType === "string" && format === "datetime";
12612
+ refuse(
12613
+ `${subjectOf(source, path2)} uses \`.dateFormat()\` on ${zoned ? "z.iso.datetime() with a zone \u2014 an instant, not a wall clock" : "a type that is not a date string"}. Only z.iso.date(), z.iso.datetime({ local: true }) and z.iso.time() take a format.`,
12614
+ source,
12615
+ path2,
12616
+ zoned ? "datetime" : ins.resolvedType ?? "unknown"
12617
+ );
12618
+ }
12619
+ if (!kind) {
12620
+ return;
12621
+ }
12622
+ if (pattern !== void 0) {
12623
+ try {
12624
+ compilePattern(pattern, kind);
12625
+ } catch (error) {
12626
+ if (error instanceof DateFormatError) {
12627
+ refuse(`${subjectOf(source, path2)}: \`.dateFormat('${pattern}')\` ${error.message}.`, source, path2, pattern);
12628
+ }
12629
+ throw error;
12630
+ }
12631
+ }
12632
+ const fallback = ins.defaultValue;
12633
+ if (fallback === void 0 || fallback === null) {
12634
+ return;
12635
+ }
12636
+ const written = patternOf(ins, kind);
12637
+ const fits = typeof fallback === "string" && (pattern !== void 0 ? !!parseInPattern(fallback, pattern, kind) : ((parts) => !!parts && toCanonical(parts, kind) === fallback)(parseIso(fallback, kind)));
12638
+ if (!fits) {
12639
+ refuse(
12640
+ `${subjectOf(source, path2)} has the default ${JSON.stringify(fallback)}, which is not written in ${written.replace(/'T'/, "T")} \u2014 a default is handed to \`execute\` as written, so write it in the field's own format.`,
12641
+ source,
12642
+ path2,
12643
+ String(fallback)
12644
+ );
12645
+ }
12646
+ }
12270
12647
  function assertField(schema, source, path2, seen, scope2, topLevel = false) {
12271
12648
  if (!schema || seen.has(schema)) {
12272
12649
  return;
@@ -12285,6 +12662,7 @@ function assertField(schema, source, path2, seen, scope2, topLevel = false) {
12285
12662
  refuseCatch(source, path2);
12286
12663
  }
12287
12664
  assertDictionaryBinding(schema, source, path2, scope2);
12665
+ assertDateString(schema, source, path2);
12288
12666
  if (!ins.resolvedType || !SUPPORTED_TYPES.has(ins.resolvedType)) {
12289
12667
  refuseType(source, path2, ins.resolvedType);
12290
12668
  }
@@ -12474,7 +12852,6 @@ function declaredAbsence(schema) {
12474
12852
  function coerces(schema) {
12475
12853
  return inspect(schema).core?._zod?.def?.coerce === true;
12476
12854
  }
12477
- var parsesJson = (schema) => !!inspect(schema).meta.frJson;
12478
12855
  var OPEN_TYPES = /* @__PURE__ */ new Set(["unknown", "any"]);
12479
12856
  var isOpenType = (schema) => OPEN_TYPES.has(inspect(schema).coreType);
12480
12857
  function requiredOpenType(schema) {
@@ -12496,7 +12873,7 @@ function requiredOpenType(schema) {
12496
12873
  return false;
12497
12874
  }
12498
12875
  function probeAbsence(schema) {
12499
- if (coerces(schema) || parsesJson(schema)) {
12876
+ if (coerces(schema)) {
12500
12877
  return declaredAbsence(schema);
12501
12878
  }
12502
12879
  if (requiredOpenType(schema)) {
@@ -12523,7 +12900,7 @@ function absenceOf(schema) {
12523
12900
  if (cached) {
12524
12901
  return cached;
12525
12902
  }
12526
- const probed = { ...probeAbsence(schema), blankIsValue: isOpenType(schema) && !parsesJson(schema) };
12903
+ const probed = { ...probeAbsence(schema), blankIsValue: isOpenType(schema) };
12527
12904
  probeCache.set(schema, probed);
12528
12905
  return probed;
12529
12906
  }
@@ -12541,10 +12918,39 @@ function planField(name, schema) {
12541
12918
  keepsEmpty,
12542
12919
  blankIsValue,
12543
12920
  passThroughDate: passesDateThrough(ins),
12544
- restoresDates: hasPassThroughDate(schema, inspect, shapeEntries)
12921
+ restoresDates: hasPassThroughDate(schema, inspect, shapeEntries),
12922
+ dateString: dateStringKind(ins),
12923
+ formatsDates: hasDateFormat(schema)
12545
12924
  };
12546
12925
  }
12547
12926
 
12927
+ // ../../flow-extension-runner/src/v2/params/schema/notices.ts
12928
+ var sink;
12929
+ var currentField;
12930
+ function collectNotices(fn) {
12931
+ const outer = sink;
12932
+ const notices = [];
12933
+ sink = notices;
12934
+ try {
12935
+ return { result: fn(), notices };
12936
+ } finally {
12937
+ sink = outer;
12938
+ outer?.push(...notices);
12939
+ }
12940
+ }
12941
+ function withinField(field, fn) {
12942
+ const outer = currentField;
12943
+ currentField = field;
12944
+ try {
12945
+ return fn();
12946
+ } finally {
12947
+ currentField = outer;
12948
+ }
12949
+ }
12950
+ function notice(entry) {
12951
+ sink?.push({ field: currentField, ...entry });
12952
+ }
12953
+
12548
12954
  // ../../flow-extension-runner/src/v2/params/schema/coerce.ts
12549
12955
  var ok = (value) => ({ ok: true, value });
12550
12956
  var fail = (expected) => ({ ok: false, expected });
@@ -12619,16 +13025,6 @@ function toBooleanValue(value) {
12619
13025
  const lowered = value.trim().toLowerCase();
12620
13026
  return TRUE.has(lowered) ? ok(true) : FALSE.has(lowered) ? ok(false) : fail("boolean");
12621
13027
  }
12622
- function toJsonValue(value) {
12623
- if (typeof value !== "string") {
12624
- return ok(value);
12625
- }
12626
- try {
12627
- return ok(JSON.parse(value));
12628
- } catch {
12629
- return fail("json");
12630
- }
12631
- }
12632
13028
  function coerceValue(value, coreType) {
12633
13029
  if (coreType === "string") {
12634
13030
  return toStringValue(value);
@@ -12726,8 +13122,20 @@ function coerceLeaf(value, ins) {
12726
13122
  if (ins.branches) {
12727
13123
  return ok(coerceUnion(value, ins.branches));
12728
13124
  }
12729
- if (ins.meta.frJson) {
12730
- return toJsonValue(value);
13125
+ const kind = dateStringKind(ins);
13126
+ if (kind) {
13127
+ const { canonical, fromTimestamp } = toDateString(value, ins, kind);
13128
+ if (canonical === void 0) {
13129
+ return fail(expectedDateString(ins, kind));
13130
+ }
13131
+ if (fromTimestamp) {
13132
+ notice({
13133
+ message: "a timestamp was converted to a date string in the server time zone (FR-3920 lenient period)",
13134
+ value,
13135
+ converted: canonical
13136
+ });
13137
+ }
13138
+ return ok(canonical);
12731
13139
  }
12732
13140
  const format = formatOf(ins);
12733
13141
  if (ins.coreType === "string" && isConvertibleIso(format)) {
@@ -12762,7 +13170,7 @@ function isBlank(value, ins, schema) {
12762
13170
  if (absenceOf(schema).blankIsValue) {
12763
13171
  return absenceOf(schema).absorbsBlank;
12764
13172
  }
12765
- return ins.coreType !== "string" || absenceOf(schema).absorbsBlank;
13173
+ return ins.coreType !== "string" || !!dateStringKind(ins) || absenceOf(schema).absorbsBlank;
12766
13174
  }
12767
13175
  function absentAs(schema, value) {
12768
13176
  const { absence } = absenceOf(schema);
@@ -12823,9 +13231,7 @@ var EXPECTED = {
12823
13231
  object: "an object",
12824
13232
  array: "an array",
12825
13233
  // zod's own token for `z.record()`, which the author declared as a map — to a person it is an object.
12826
- record: "an object",
12827
- // `z.json()`. Not a zod token — ./coerce.ts raises it when the submitted text will not parse.
12828
- json: "valid JSON"
13234
+ record: "an object"
12829
13235
  };
12830
13236
  var requiredMessage = (plan) => `\xAB${plan.label}\xBB is required`;
12831
13237
  var invalidTypeMessage = (plan, expected) => `\xAB${plan.label}\xBB must be ${EXPECTED[expected] ?? expected}`;
@@ -12852,7 +13258,7 @@ function resolveTarget(plan, segments, fieldValue) {
12852
13258
  schema = nested[1];
12853
13259
  label = labelOf(segment, schema);
12854
13260
  }
12855
- return { label, value, found };
13261
+ return { label, value, found, schema: found ? schema : void 0 };
12856
13262
  }
12857
13263
  function bound(value, plan) {
12858
13264
  if (plan.coreType !== "date" || typeof value !== "number") {
@@ -12874,6 +13280,11 @@ function toFieldIssue(plan, issue, fieldValue) {
12874
13280
  if (isAuthored(issue)) {
12875
13281
  return { path: path2, code, message: issue.message };
12876
13282
  }
13283
+ const dateKind = target.schema ? dateStringKind(inspect(target.schema)) : void 0;
13284
+ const dateMissing = target.value == null || target.value === "";
13285
+ if (dateKind && (code === "invalid_type" || code === "invalid_format")) {
13286
+ return dateMissing ? { path: path2, code, message: requiredMessage(named) } : { path: path2, code, message: invalidTypeMessage(named, expectedDateString(inspect(target.schema), dateKind)) };
13287
+ }
12877
13288
  if (code === "invalid_type") {
12878
13289
  const received = issue.received;
12879
13290
  const absent = segments.length ? target.found && target.value == null : received === "undefined" || received === "null" || issue.expected === void 0;
@@ -12918,7 +13329,7 @@ function isAbsent(value, plan) {
12918
13329
  if (plan.blankIsValue) {
12919
13330
  return plan.absorbsBlank;
12920
13331
  }
12921
- return plan.coreType !== "string" || plan.absorbsBlank;
13332
+ return plan.coreType !== "string" || !!plan.dateString || plan.absorbsBlank;
12922
13333
  }
12923
13334
  function normalizeAbsence(value, plan) {
12924
13335
  if (plan.absence === "required") {
@@ -12957,7 +13368,7 @@ function normalizeField(value, plan) {
12957
13368
  return restore(validate(coerced.value, plan), value, plan);
12958
13369
  }
12959
13370
  function restore(result, original, plan) {
12960
- if (!plan.restoresDates || !result.present || result.issues.length) {
13371
+ if (!(plan.restoresDates || plan.formatsDates) || !result.present || result.issues.length) {
12961
13372
  return result;
12962
13373
  }
12963
13374
  if (plan.passThroughDate) {
@@ -12977,6 +13388,10 @@ function restoreDeep(output, original, schema) {
12977
13388
  const branch = ins.branches.find((option) => accepts(option, output));
12978
13389
  return branch ? restoreDeep(output, original, branch) : output;
12979
13390
  }
13391
+ const kind = dateStringKind(ins);
13392
+ if (kind) {
13393
+ return typeof output === "string" && original !== "" ? canonicalToPattern(output, ins, kind) : output;
13394
+ }
12980
13395
  const element = ins.core?._zod?.def?.element;
12981
13396
  if (ins.coreType === "array" && element && Array.isArray(output) && Array.isArray(original)) {
12982
13397
  return output.map((item, index) => restoreDeep(item, original[index], element));
@@ -13066,7 +13481,7 @@ var Params = class {
13066
13481
  const values = {};
13067
13482
  const issues = [];
13068
13483
  for (const plan of this.plans()) {
13069
- const result = normalizeField(source[plan.name], plan);
13484
+ const result = withinField(plan.name, () => normalizeField(source[plan.name], plan));
13070
13485
  if (result.issues.length) {
13071
13486
  issues.push(...result.issues);
13072
13487
  } else if (result.present) {
@@ -13221,6 +13636,9 @@ function extendPrototype() {
13221
13636
  }
13222
13637
  return this.meta({ frDictionary: binding });
13223
13638
  };
13639
+ proto.dateFormat = function dateFormat(pattern) {
13640
+ return this.meta({ frDateFormat: pattern });
13641
+ };
13224
13642
  proto.labels = function labels(byValue) {
13225
13643
  return this.meta({ frLabels: byValue });
13226
13644
  };
@@ -13243,10 +13661,9 @@ function text() {
13243
13661
  return import_zod2.z.string().meta({ frWidget: FlowExtensionParamWidgetTypes.MULTI_LINE_TEXT });
13244
13662
  }
13245
13663
  function json() {
13246
- return import_zod2.z.unknown().nonoptional().meta({
13247
- frWidget: FlowExtensionParamWidgetTypes.MULTI_LINE_TEXT,
13248
- frJson: true
13249
- });
13664
+ throw new Error(
13665
+ "`z.json()` is not supported \u2014 declare `z.unknown()` for any value passed as given (`.required()` to make it required), or declare the shape: `z.object({ \u2026 })` / `z.array(\u2026)` also accept JSON text and parse it."
13666
+ );
13250
13667
  }
13251
13668
  var namespace = Object.create(import_zod2.z);
13252
13669
  Object.defineProperties(namespace, {
@@ -13260,7 +13677,7 @@ Object.defineProperties(namespace, {
13260
13677
  var z = namespace;
13261
13678
 
13262
13679
  // ../../flow-extension-runner/src/v2/params/json/values.ts
13263
- function toJsonValue2(value) {
13680
+ function toJsonValue(value) {
13264
13681
  if (typeof value === "bigint") {
13265
13682
  return { $bigint: value.toString() };
13266
13683
  }
@@ -13268,10 +13685,10 @@ function toJsonValue2(value) {
13268
13685
  return { $date: value.toISOString() };
13269
13686
  }
13270
13687
  if (Array.isArray(value)) {
13271
- return value.map(toJsonValue2);
13688
+ return value.map(toJsonValue);
13272
13689
  }
13273
13690
  if (value && typeof value === "object") {
13274
- return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, toJsonValue2(inner)]));
13691
+ return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, toJsonValue(inner)]));
13275
13692
  }
13276
13693
  return value;
13277
13694
  }
@@ -13306,18 +13723,18 @@ function encodeCheck(check) {
13306
13723
  switch (def.check) {
13307
13724
  // strings and arrays
13308
13725
  case "min_length":
13309
- return at("min", toJsonValue2(def.minimum));
13726
+ return at("min", toJsonValue(def.minimum));
13310
13727
  case "max_length":
13311
- return at("max", toJsonValue2(def.maximum));
13728
+ return at("max", toJsonValue(def.maximum));
13312
13729
  case "length_equals":
13313
- return at("length", toJsonValue2(def.length));
13730
+ return at("length", toJsonValue(def.length));
13314
13731
  // numbers and bigints
13315
13732
  case "greater_than":
13316
- return at("min", toJsonValue2(def.value), def.inclusive ? void 0 : true);
13733
+ return at("min", toJsonValue(def.value), def.inclusive ? void 0 : true);
13317
13734
  case "less_than":
13318
- return at("max", toJsonValue2(def.value), def.inclusive ? void 0 : true);
13735
+ return at("max", toJsonValue(def.value), def.inclusive ? void 0 : true);
13319
13736
  case "multiple_of":
13320
- return at("multipleOf", toJsonValue2(def.value));
13737
+ return at("multipleOf", toJsonValue(def.value));
13321
13738
  case "number_format":
13322
13739
  return def.format === "safeint" || def.format === "int32" ? at("int") : void 0;
13323
13740
  // the string sub-formats that are checks rather than types
@@ -13478,7 +13895,7 @@ function encodeMeta(meta, field, scope2, loaderId) {
13478
13895
  if (hasFunction(source)) {
13479
13896
  throw new Error(`Cannot encode "${field}": its metadata holds a function, which has no wire form.`);
13480
13897
  }
13481
- const encoded = toJsonValue2(source);
13898
+ const encoded = toJsonValue(source);
13482
13899
  return Object.keys(encoded).length ? encoded : void 0;
13483
13900
  }
13484
13901
  function isLoose(core) {
@@ -13488,11 +13905,11 @@ function isLoose(core) {
13488
13905
  function encodeValues(core, type) {
13489
13906
  if (type === "enum") {
13490
13907
  const entries = core?._zod?.def?.entries ?? {};
13491
- return Object.values(entries).map(toJsonValue2);
13908
+ return Object.values(entries).map(toJsonValue);
13492
13909
  }
13493
13910
  if (type === "literal") {
13494
13911
  const values = core?._zod?.def?.values ?? [];
13495
- return values.map(toJsonValue2);
13912
+ return values.map(toJsonValue);
13496
13913
  }
13497
13914
  return void 0;
13498
13915
  }
@@ -13520,9 +13937,10 @@ function encodeField(name, schema, seen = /* @__PURE__ */ new Set(), loaderId, s
13520
13937
  name,
13521
13938
  type,
13522
13939
  ...format ? { format } : {},
13940
+ ...format === "datetime" && core?._zod?.def?.local ? { local: true } : {},
13523
13941
  ...optional ? { optional: true } : {},
13524
13942
  ...nullable ? { nullable: true } : {},
13525
- ...hasDefault ? { default: toJsonValue2(defaultValue) } : {},
13943
+ ...hasDefault ? { default: toJsonValue(defaultValue) } : {},
13526
13944
  ...checks.length ? { checks } : {},
13527
13945
  ...values?.length ? { values } : {},
13528
13946
  ...meta ? { meta } : {},
@@ -14172,6 +14590,9 @@ var ExecutionContext = class _ExecutionContext {
14172
14590
  get logger() {
14173
14591
  return this.#options.logger ?? defaultLogger;
14174
14592
  }
14593
+ get invocation() {
14594
+ return this.#options.invocation ?? {};
14595
+ }
14175
14596
  get config() {
14176
14597
  this.#config ??= this.#extension.config.resolve(this.#options.configs);
14177
14598
  return this.#config;
@@ -14324,6 +14745,10 @@ var DictionaryMethod = class extends ExtensionMethod {
14324
14745
  return this.criteria.keys();
14325
14746
  }
14326
14747
  // ── runtime ────────────────────────────────────────────────────────────────
14748
+ // `search` is always text, trimmed (FR-3910): `''` when the author typed nothing — the console then sends no
14749
+ // `search` at all — or only spaces. So a handler never guards it: `search ? { q: search } : undefined`, and
14750
+ // `search.toLowerCase()` as is. Surrounding spaces never mean anything to a lookup.
14751
+ //
14327
14752
  // Two-stage: the `{ search, cursor, criteria }` envelope the runtime owns, then the author-declared
14328
14753
  // criteria through the shared pipeline — reported as a criteria failure so the console can point at the
14329
14754
  // dependent fields rather than the whole call.
@@ -14332,7 +14757,7 @@ var DictionaryMethod = class extends ExtensionMethod {
14332
14757
  const payload = input.parseField("payload", DictionaryPayloadSchema);
14333
14758
  const criteria = this.criteria.normalize(this.#resolveAliases(payload.criteria), input.invalidCriteria());
14334
14759
  return {
14335
- search: payload.search,
14760
+ search: payload.search?.trim() ?? "",
14336
14761
  cursor: payload.cursor,
14337
14762
  criteria
14338
14763
  };
@@ -15683,7 +16108,23 @@ var Extension = class {
15683
16108
  // generated loader, SYSTEM seam — arrives here through the same three steps.
15684
16109
  async run(methodName, methodData, ctx) {
15685
16110
  const method = this.getMethod(methodName);
15686
- return method.execute(method.validate(methodData ?? {}), ctx);
16111
+ const { result: input, notices } = collectNotices(() => method.validate(methodData ?? {}));
16112
+ this.#reportNotices(notices, methodName, ctx);
16113
+ return method.execute(input, ctx);
16114
+ }
16115
+ // One warning per value the pipeline accepted only under a temporary rule — today a timestamp converted for
16116
+ // a date-string field (FR-3920 lenient period). Named well enough to find the flow still holding one.
16117
+ #reportNotices(notices, methodName, ctx) {
16118
+ for (const { message, field, value, converted } of notices) {
16119
+ ctx.logger.warn(`[flow-extension:${this.id}] ${methodName}: param "${field ?? "?"}": ${message}`, {
16120
+ serviceId: this.id,
16121
+ method: methodName,
16122
+ param: field,
16123
+ value,
16124
+ converted,
16125
+ ...ctx.invocation
16126
+ });
16127
+ }
15687
16128
  }
15688
16129
  // ── output model ────────────────────────────────────────────────────────────
15689
16130
  toConfigItems() {
@@ -16050,7 +16491,13 @@ async function runServiceMethod2(data) {
16050
16491
  retrieveNewS3Token
16051
16492
  };
16052
16493
  const files = extension.props.usesFileStorage ? (data.createFiles ?? defaultCreateFiles)(filesOptions) : void 0;
16053
- const ctx = extension.createContext({ configs: data.configs, accessToken, logger: data.logger, files });
16494
+ const ctx = extension.createContext({
16495
+ configs: data.configs,
16496
+ accessToken,
16497
+ logger: data.logger,
16498
+ files,
16499
+ invocation: { flowId, executionId }
16500
+ });
16054
16501
  return extension.run(methodName, methodData, ctx);
16055
16502
  }
16056
16503